@wise/dynamic-flow-client 3.5.0-experimental-b041af5 → 3.5.0-experimental-63c768d

package/build/legacy/common/validators/schemas/schema-validators.spec.js

@@ -0,0 +1,157 @@
+import { isValidSchema } from './schema-validators';
+describe('Given a library for validating json schema models', function () {
+    var schema;
+    describe('when validating an object schema', function () {
+        beforeEach(function () {
+            schema = {
+                type: 'object',
+                properties: {
+                    a: {
+                        type: 'number',
+                        minimum: 2
+                    },
+                    b: {
+                        type: 'string',
+                        minLength: 3
+                    },
+                    c: {
+                        "const": true
+                    }
+                },
+                required: ['a', 'c'],
+                displayOrder: ['a', 'b', 'c']
+            };
+        });
+        it('should return false if the value is of an incorrect type', function () {
+            expect(isValidSchema([1], schema)).toBe(false);
+        });
+        it('should return false if a required property is missing', function () {
+            expect(isValidSchema({}, schema)).toBe(false);
+        });
+        it('should return false is a required property does not validate', function () {
+            expect(isValidSchema({ a: 1, c: true }, schema)).toBe(false);
+        });
+        it('should return false if an optional property is invalid', function () {
+            expect(isValidSchema({ a: 2, b: 'c', c: true }, schema)).toBe(false);
+        });
+        it('should return true if required properties validate and non-required fields are missing', function () {
+            expect(isValidSchema({ a: 2, c: true }, schema)).toBe(true);
+        });
+        it('should return true if all properties validate', function () {
+            expect(isValidSchema({ a: 2, b: 'cde', c: true }, schema)).toBe(true);
+        });
+    });
+    describe('when validating an array schema', function () {
+        beforeEach(function () {
+            schema = {
+                type: 'array',
+                addItemTitle: '',
+                editItemTitle: '',
+                items: {
+                    type: 'string',
+                    minLength: 2
+                },
+                minItems: 2,
+                maxItems: 2
+            };
+        });
+        it('should return false if not an array', function () {
+            expect(isValidSchema({ a: 1 }, schema)).toBe(false);
+        });
+        it('should return false if the array is too small', function () {
+            expect(isValidSchema(['ab'], schema)).toBe(false);
+        });
+        it('should return false if the array is too long', function () {
+            expect(isValidSchema(['ab', 'cd', 'ef'], schema)).toBe(false);
+        });
+        it('should return false if any of the items do not validate', function () {
+            expect(isValidSchema(['ab', 'c'], schema)).toBe(false);
+        });
+        it('should return true is the array is correct size and items are valid', function () {
+            expect(isValidSchema(['ab', 'cd'], schema)).toBe(true);
+        });
+    });
+    describe('when validating a oneOf schema', function () {
+        beforeEach(function () {
+            schema = {
+                oneOf: [
+                    {
+                        type: 'string',
+                        minLength: 2
+                    },
+                    {
+                        type: 'number',
+                        minimum: 2
+                    },
+                ]
+            };
+        });
+        it('should return false if neither schema validates', function () {
+            expect(isValidSchema(true, schema)).toBe(false);
+            expect(isValidSchema('a', schema)).toBe(false);
+            expect(isValidSchema(1, schema)).toBe(false);
+        });
+        it('should return true if either schema validates', function () {
+            expect(isValidSchema('ab', schema)).toBe(true);
+            expect(isValidSchema(2, schema)).toBe(true);
+        });
+    });
+    describe('when validating an allOf schema', function () {
+        beforeEach(function () {
+            schema = {
+                allOf: [
+                    {
+                        type: 'object',
+                        properties: {
+                            a: {
+                                type: 'string',
+                                minLength: 2
+                            }
+                        },
+                        displayOrder: ['a'],
+                        required: ['a']
+                    },
+                    {
+                        type: 'object',
+                        properties: {
+                            b: {
+                                type: 'number',
+                                minimum: 2
+                            }
+                        },
+                        displayOrder: ['b'],
+                        required: ['b']
+                    },
+                ]
+            };
+        });
+        it('should return false if only one schema is present', function () {
+            expect(isValidSchema({ a: 'bc' }, schema)).toBe(false);
+            expect(isValidSchema({ b: 2 }, schema)).toBe(false);
+        });
+        it('should return false if any schemas are invalid', function () {
+            expect(isValidSchema({ a: 'bc', b: 1 }, schema)).toBe(false);
+        });
+        it('should return true if both schemas validate', function () {
+            expect(isValidSchema({ a: 'bc', b: 2 }, schema)).toBe(true);
+        });
+    });
+    describe('when validating a hidden required schema', function () {
+        var schema = {
+            type: 'object',
+            properties: {
+                a: {
+                    hidden: true,
+                    type: 'number',
+                    minimum: 2
+                }
+            },
+            required: ['a'],
+            displayOrder: ['a']
+        };
+        it('should return true for both valid and invalid schemas', function () {
+            expect(isValidSchema({ a: 3 }, schema)).toBe(true);
+            expect(isValidSchema({}, schema)).toBe(true);
+        });
+    });
+});

package/build/legacy/common/validators/types/type-validators.spec.js

@@ -0,0 +1,147 @@
+import { isString, isNumber, isInteger, isBoolean, isArray, isObject, isNull, isUndefined, } from './type-validators';
+describe('type-validators', function () {
+    describe('isString', function () {
+        it('should return true when the value is a string', function () {
+            expect(isString('a')).toBe(true);
+            expect(isString('')).toBe(true);
+        });
+        it('should return false when the value is a different primitive types', function () {
+            expect(isString(1)).toBe(false);
+            expect(isString(true)).toBe(false);
+            expect(isString(undefined)).toBe(false);
+            expect(isString(null)).toBe(false);
+            expect(isString(NaN)).toBe(false);
+        });
+        it('should return false when the value is a complex type', function () {
+            expect(isString([])).toBe(false);
+            expect(isString({})).toBe(false);
+        });
+    });
+    describe('isNumber', function () {
+        it('should return true when the value is a number', function () {
+            expect(isNumber(1)).toBe(true);
+            expect(isNumber(0)).toBe(true);
+            expect(isNumber(1.23)).toBe(true);
+            expect(isNumber(-1)).toBe(true);
+        });
+        it('should return false when the value is a different primitive type', function () {
+            expect(isNumber('a')).toBe(false);
+            expect(isNumber(true)).toBe(false);
+            expect(isNumber(undefined)).toBe(false);
+            expect(isNumber(null)).toBe(false);
+            expect(isNumber(NaN)).toBe(false);
+        });
+        it('should return false when the value is a complex type', function () {
+            expect(isNumber([])).toBe(false);
+            expect(isNumber({})).toBe(false);
+        });
+    });
+    describe('isInteger', function () {
+        it('should return true when the value is a integer', function () {
+            expect(isInteger(1)).toBe(true);
+            expect(isInteger(0)).toBe(true);
+            expect(isInteger(-1)).toBe(true);
+        });
+        it('should return false when the value is a float', function () {
+            expect(isInteger(1.23)).toBe(false);
+        });
+        it('should return false when the value is a different primitive type', function () {
+            expect(isInteger('a')).toBe(false);
+            expect(isInteger(true)).toBe(false);
+            expect(isInteger(undefined)).toBe(false);
+            expect(isInteger(null)).toBe(false);
+            expect(isInteger(NaN)).toBe(false);
+        });
+        it('should return false when the value is a complex type', function () {
+            expect(isInteger([])).toBe(false);
+            expect(isInteger({})).toBe(false);
+        });
+    });
+    describe('isBoolean', function () {
+        it('should return true when the value is a boolean', function () {
+            expect(isBoolean(true)).toBe(true);
+            expect(isBoolean(false)).toBe(true);
+        });
+        it('should return false when the value is a different primitive type', function () {
+            expect(isBoolean(1)).toBe(false);
+            expect(isBoolean('a')).toBe(false);
+            expect(isBoolean(undefined)).toBe(false);
+            expect(isBoolean(null)).toBe(false);
+            expect(isBoolean(NaN)).toBe(false);
+        });
+        it('should return false when the value is a complex type', function () {
+            expect(isBoolean([])).toBe(false);
+            expect(isBoolean({})).toBe(false);
+        });
+    });
+    describe('isArray', function () {
+        it('should return true when the value is an array', function () {
+            expect(isArray([1])).toBe(true);
+            expect(isArray([])).toBe(true);
+        });
+        it('should return false when the value is null or undefined', function () {
+            expect(isArray(undefined)).toBe(false);
+            expect(isArray(null)).toBe(false);
+        });
+        it('should return false when the value is a different primitive type', function () {
+            expect(isArray(1)).toBe(false);
+            expect(isArray('a')).toBe(false);
+            expect(isArray(true)).toBe(false);
+            expect(isArray(NaN)).toBe(false);
+        });
+        it('should return false when the value is an object', function () {
+            expect(isArray({})).toBe(false);
+        });
+    });
+    describe('isObject', function () {
+        it('should return true when the value is an object', function () {
+            expect(isObject({ a: 1 })).toBe(true);
+            expect(isObject({})).toBe(true);
+        });
+        it('should return false when the value is an array', function () {
+            expect(isObject([])).toBe(false);
+        });
+        it('should return false when the value is a primitive', function () {
+            expect(isObject(1)).toBe(false);
+            expect(isObject('a')).toBe(false);
+            expect(isObject(true)).toBe(false);
+            expect(isObject(NaN)).toBe(false);
+        });
+        it('should return false when the value is null or undefined', function () {
+            expect(isObject(undefined)).toBe(false);
+            expect(isObject(null)).toBe(false);
+        });
+    });
+    describe('isNull', function () {
+        it('should return true when the value is null', function () {
+            expect(isNull(null)).toBe(true);
+        });
+        it('should return false when the value is undefined', function () {
+            expect(isNull(undefined)).toBe(false);
+        });
+        it('should return false when the value is a primitive', function () {
+            expect(isNull(0)).toBe(false);
+            expect(isNull(false)).toBe(false);
+            expect(isNull(NaN)).toBe(false);
+        });
+        it('should return false when the value is a complex type', function () {
+            expect(isNull([])).toBe(false);
+            expect(isNull({})).toBe(false);
+        });
+    });
+    describe('isUndefined', function () {
+        it('should return true when the value is undefined', function () {
+            expect(isUndefined(undefined)).toBe(true);
+        });
+        it('should return false when the value is a primitive', function () {
+            expect(isUndefined(0)).toBe(false);
+            expect(isUndefined(false)).toBe(false);
+            expect(isUndefined(null)).toBe(false);
+            expect(isUndefined(NaN)).toBe(false);
+        });
+        it('should return false when the value is a complex type', function () {
+            expect(isNull([])).toBe(false);
+            expect(isNull({})).toBe(false);
+        });
+    });
+});

package/build/legacy/common/validators/validationFailures/validation-failures.spec.js

@@ -0,0 +1,198 @@
+import { getValidationFailures } from './validation-failures';
+describe('Given a library for identifying validation failures', function () {
+    var schema;
+    describe('when value is null and schema required', function () {
+        beforeEach(function () {
+            schema = {
+                type: 'string',
+                minLength: 3,
+                maxLength: 10,
+                pattern: '^[a-z]+$'
+            };
+        });
+        it('should return only required', function () {
+            expect(getValidationFailures(null, schema, true)).toStrictEqual(['required']);
+        });
+    });
+    describe('when validating a string schema', function () {
+        beforeEach(function () {
+            schema = {
+                type: 'string',
+                minLength: 3,
+                maxLength: 6,
+                pattern: '^[a-z]+$'
+            };
+        });
+        it('should return an empty array for valid string', function () {
+            expect(getValidationFailures('string', schema, false)).toStrictEqual([]);
+        });
+        it('should return an empty array for null if not required', function () {
+            expect(getValidationFailures(null, schema, false)).toStrictEqual([]);
+        });
+        it('should return minLength when too short', function () {
+            expect(getValidationFailures('st', schema, false)).toStrictEqual(['minLength']);
+        });
+        it('should return [maxLength] when too long', function () {
+            expect(getValidationFailures('strings', schema, false)).toStrictEqual(['maxLength']);
+        });
+        it('should return [pattern] when does not pass regex', function () {
+            expect(getValidationFailures('STRING', schema, false)).toStrictEqual(['pattern']);
+        });
+        it('should return [type] when incorrect data type', function () {
+            expect(getValidationFailures(1234, schema, false)).toStrictEqual(['type']);
+        });
+    });
+    describe('when validating a string date', function () {
+        beforeEach(function () {
+            schema = {
+                type: 'string',
+                minimum: '2000-01-01T00:00:00Z',
+                maximum: '2010-01-01T00:00:00Z'
+            };
+        });
+        it('should return an empty array for valid date', function () {
+            expect(getValidationFailures('2005-01-01T00:00:00Z', schema, false)).toStrictEqual([]);
+        });
+        it('should return [min] when date is too early', function () {
+            expect(getValidationFailures('1999-01-01T00:00:00Z', schema, false)).toStrictEqual([
+                'minimum',
+            ]);
+        });
+        it('should return [max] when date is too late', function () {
+            expect(getValidationFailures('2011-01-01T00:00:00Z', schema, false)).toStrictEqual([
+                'maximum',
+            ]);
+        });
+    });
+    describe('when validating a number schema', function () {
+        beforeEach(function () {
+            schema = {
+                type: 'number',
+                minimum: 0,
+                maximum: 20
+            };
+        });
+        it('should return an empty array for an integer in range', function () {
+            expect(getValidationFailures(10, schema, false)).toStrictEqual([]);
+        });
+        it('should return an empty array for a float in range', function () {
+            expect(getValidationFailures(12.34, schema, false)).toStrictEqual([]);
+        });
+        it('should return an empty array for a number that matches our min', function () {
+            expect(getValidationFailures(0, schema, false)).toStrictEqual([]);
+        });
+        it('should return an empty array for a number that matches our max', function () {
+            expect(getValidationFailures(20, schema, false)).toStrictEqual([]);
+        });
+        it('should return [min] when number is too low', function () {
+            expect(getValidationFailures(-1, schema, false)).toStrictEqual(['minimum']);
+        });
+        it('should return [max] when number is too high', function () {
+            expect(getValidationFailures(21, schema, false)).toStrictEqual(['maximum']);
+        });
+        it('should return [type] when incorrect data type', function () {
+            expect(getValidationFailures('string', schema, false)).toStrictEqual(['type']);
+        });
+    });
+    describe('when validating an integer schema', function () {
+        beforeEach(function () {
+            schema = { type: 'integer' };
+        });
+        it('should return an empty array for valid integer', function () {
+            expect(getValidationFailures(15, schema, false)).toStrictEqual([]);
+        });
+        it('should return [type] when a number is not an integer', function () {
+            expect(getValidationFailures(12.34, schema, false)).toStrictEqual(['type']);
+        });
+    });
+    describe('when validating a boolean schema', function () {
+        beforeEach(function () {
+            schema = { type: 'boolean' };
+        });
+        it('should return an empty array for valid boolean', function () {
+            expect(getValidationFailures(true, schema, false)).toStrictEqual([]);
+            expect(getValidationFailures(false, schema, false)).toStrictEqual([]);
+        });
+        it('should return [type] when incorrect data type', function () {
+            expect(getValidationFailures(1, schema, false)).toStrictEqual(['type']);
+        });
+    });
+    describe('when validating a basic const schema', function () {
+        beforeEach(function () {
+            schema = { "const": 'abcd' };
+        });
+        it('should return an empty array when the const matches', function () {
+            expect(getValidationFailures('abcd', schema, false)).toStrictEqual([]);
+        });
+        it("should return ['const'] when the const does not match", function () {
+            expect(getValidationFailures('1234', schema, false)).toStrictEqual(['const']);
+        });
+        it("should return ['const'] when null", function () {
+            expect(getValidationFailures(null, schema, false)).toStrictEqual(['const']);
+        });
+        it("should return ['const'] when undefined", function () {
+            expect(getValidationFailures(undefined, schema, false)) //
+                .toStrictEqual(['const']);
+        });
+    });
+    describe('when validating a complex const schema', function () {
+        beforeEach(function () {
+            schema = { "const": { abcd: 'abcd' } };
+        });
+        it('should return an empty array when the const matches', function () {
+            expect(getValidationFailures({ abcd: 'abcd' }, schema, false)).toStrictEqual([]);
+        });
+        it("should return ['const'] when the const does not match", function () {
+            expect(getValidationFailures({ abcd: '1234' }, schema, false)).toStrictEqual(['const']);
+        });
+    });
+    describe('when validating an array schema', function () {
+        beforeEach(function () {
+            schema = {
+                type: 'array',
+                addItemTitle: '',
+                editItemTitle: '',
+                items: {
+                    type: 'number'
+                },
+                minItems: 2,
+                maxItems: 2
+            };
+        });
+        it('should return an empty array for a valid array', function () {
+            expect(getValidationFailures([1, 2], schema, false)).toStrictEqual([]);
+        });
+        it('should return [minItems] when the array is too small', function () {
+            expect(getValidationFailures([1], schema, false)).toStrictEqual(['minItems']);
+        });
+        it('should return [maxItems] when the array is too big', function () {
+            expect(getValidationFailures([1, 2, 3], schema, false)).toStrictEqual(['maxItems']);
+        });
+        it('should return [type] when incorrect data type', function () {
+            expect(getValidationFailures({ a: 1 }, schema, false)).toStrictEqual(['type']);
+        });
+    });
+    describe('when validating an object schema', function () {
+        beforeEach(function () {
+            schema = {
+                type: 'object',
+                properties: {
+                    a: {
+                        type: 'number'
+                    }
+                },
+                required: ['a'],
+                displayOrder: ['a']
+            };
+        });
+        it('should return an empty array for a valid object', function () {
+            expect(getValidationFailures({ a: 1 }, schema, false)).toStrictEqual([]);
+        });
+        it('should return [required] when required properties are missing', function () {
+            expect(getValidationFailures({}, schema, false)).toStrictEqual(['required']);
+        });
+        it('should return [type] when incorrect data type', function () {
+            expect(getValidationFailures([1], schema, false)).toStrictEqual(['type']);
+        });
+    });
+});

package/build/legacy/common/validators/validationFailures/validation-failures.utils.spec.js

@@ -0,0 +1,145 @@
+import { isValidRequired, isValidMinLength, isValidMaxLength, isValidMinimum, isValidMaximum, isValidPattern, isValidMinItems, isValidMaxItems, isValidRequiredArray, } from './validation-failures.utils';
+describe('Given a library for validating json schema rules', function () {
+    describe('when establishing if a value passes required validation', function () {
+        it('should return true if required and value defined', function () {
+            expect(isValidRequired('something', true)).toBe(true);
+        });
+        it('should return false if required and value undefined', function () {
+            expect(isValidRequired(undefined, true)).toBe(false);
+        });
+        it('should return true if not required', function () {
+            expect(isValidRequired(undefined, false)).toBe(true);
+            expect(isValidRequired('something', false)).toBe(true);
+        });
+    });
+    describe('when establishing if a value passes minLength validation', function () {
+        it('should return true if minLength exists and value matches or exceeds it', function () {
+            expect(isValidMinLength('a', 1)).toBe(true);
+            expect(isValidMinLength('ab', 1)).toBe(true);
+        });
+        it('should return false if minLength exists and value undefined', function () {
+            expect(isValidMinLength(undefined, 1)).toBe(false);
+        });
+        it('should return false if minLength exists and value too short', function () {
+            expect(isValidMinLength('', 1)).toBe(false);
+        });
+        it('should return true if minLength not defined', function () {
+            expect(isValidMinLength('a', undefined)).toBe(true);
+        });
+    });
+    describe('when establishing if a value passes maxLength validation', function () {
+        it('should return true if maxLength exists and value matches or shorter than it', function () {
+            expect(isValidMaxLength('', 2)).toBe(true);
+            expect(isValidMaxLength('a', 2)).toBe(true);
+            expect(isValidMaxLength('ab', 2)).toBe(true);
+        });
+        it('should return false if maxLength exists and value undefined', function () {
+            expect(isValidMaxLength(undefined, 2)).toBe(false);
+        });
+        it('should return false if maxLength exists and value too long', function () {
+            expect(isValidMaxLength('abc', 2)).toBe(false);
+        });
+        it('should return true if maxLength not defined', function () {
+            expect(isValidMaxLength('a', undefined)).toBe(true);
+        });
+    });
+    describe('when establishing if a value passes pattern validation', function () {
+        it('should return true if pattern exists and value matches it', function () {
+            expect(isValidPattern('a', '[a-z]+')).toBe(true);
+        });
+        it('should return false if pattern exists and value undefined', function () {
+            expect(isValidPattern(undefined, '[a-z]+')).toBe(false);
+        });
+        it('should return false if pattern exists and value invalid', function () {
+            expect(isValidPattern('012', '[a-z]+')).toBe(false);
+        });
+        it('should return true if pattern not defined', function () {
+            expect(isValidPattern('a', undefined)).toBe(true);
+        });
+    });
+    describe('when establishing if a value passes minimum validation', function () {
+        it('should return true if min exists and value matches or exceeds it', function () {
+            expect(isValidMinimum(1, 1)).toBe(true);
+            expect(isValidMinimum(0, 0)).toBe(true);
+            // FIXME - these are not valid
+            // expect(isValidMinimum('2', '1')).toBe(true);
+            // expect(isValidMinimum('1', '1')).toBe(true);
+            // expect(isValidMinimum('0', '0')).toBe(true);
+        });
+        it('should return false if min exists and value undefined', function () {
+            expect(isValidMinimum(undefined, 1)).toBe(false);
+        });
+        it('should return false if min exists and value too low', function () {
+            expect(isValidMinimum(1, 2)).toBe(false);
+            expect(isValidMinimum(-1, 0)).toBe(false);
+        });
+        it('should return true if min not defined', function () {
+            expect(isValidMinimum(1, undefined)).toBe(true);
+        });
+    });
+    describe('when establishing if a value passes maximum validation', function () {
+        it('should return true if max exists and value matches or is lower than it', function () {
+            expect(isValidMaximum(2, 2)).toBe(true);
+            expect(isValidMaximum(-1, 0)).toBe(true);
+            // FIXME - these are not valid
+            // expect(isValidMaximum('2', '2')).toBe(true);
+            // expect(isValidMaximum('0', '2')).toBe(true);
+        });
+        it('should return false if max exists and value undefined', function () {
+            expect(isValidMaximum(undefined, 2)).toBe(false);
+        });
+        it('should return false if max exists and value too high', function () {
+            expect(isValidMaximum(3, 2)).toBe(false);
+        });
+        it('should return true if max not defined', function () {
+            expect(isValidMaximum(2, undefined)).toBe(true);
+        });
+    });
+    describe('when establishing if an array passes minItems validation', function () {
+        it('should return true if minItems exists and value length matches or exceeds it', function () {
+            expect(isValidMinItems([1], 1)).toBe(true);
+            expect(isValidMinItems([], 0)).toBe(true);
+        });
+        it('should return false if minItems exists and value undefined', function () {
+            expect(isValidMinItems(undefined, 1)).toBe(false);
+        });
+        it('should return false if minItems exists and value too short', function () {
+            expect(isValidMinItems([1], 2)).toBe(false);
+            expect(isValidMinItems([], 1)).toBe(false);
+        });
+        it('should return true if minItems not defined', function () {
+            expect(isValidMinItems([], undefined)).toBe(true);
+        });
+    });
+    describe('when establishing if an array passes maxItems validation', function () {
+        it('should return true if maxItems exists and value length matches or is less than it', function () {
+            expect(isValidMaxItems([1], 1)).toBe(true);
+            expect(isValidMaxItems([], 0)).toBe(true);
+        });
+        it('should return false if maxItems exists and value undefined', function () {
+            expect(isValidMaxItems(undefined, 1)).toBe(false);
+        });
+        it('should return false if maxItems exists and value too long', function () {
+            expect(isValidMaxItems([1, 2], 1)).toBe(false);
+        });
+        it('should return true if maxItems not defined', function () {
+            expect(isValidMaxItems([], undefined)).toBe(true);
+        });
+    });
+    describe('when establishing validations an array', function () {
+        it('should return true all values for a non-required input', function () {
+            expect(isValidRequiredArray([1], false)).toBe(true);
+            expect(isValidRequiredArray([], false)).toBe(true);
+            expect(isValidRequiredArray(undefined, false)).toBe(true);
+            expect(isValidRequiredArray(null, false)).toBe(true);
+        });
+        it('should return true for only array values for a required input', function () {
+            expect(isValidRequiredArray([1], true)).toBe(true);
+            expect(isValidRequiredArray([], true)).toBe(true);
+        });
+        it('should return false for values for a required input', function () {
+            expect(isValidRequiredArray(null, true)).toBe(false);
+            expect(isValidRequiredArray(undefined, true)).toBe(false);
+        });
+    });
+});

package/build/legacy/common/validators/values/value-validators.spec.js

@@ -0,0 +1,22 @@
+import { isEmpty } from './value-validators';
+describe('value-validators', function () {
+    describe('isEmpty', function () {
+        it('should return true for empty strings', function () {
+            expect(isEmpty('')).toBe(true);
+            expect(isEmpty('a')).toBe(false);
+        });
+        it('should return true for empty array', function () {
+            expect(isEmpty([])).toBe(true);
+            expect(isEmpty(['a'])).toBe(false);
+        });
+        it('should return true for empty object', function () {
+            expect(isEmpty({})).toBe(true);
+            expect(isEmpty({ a: 'a' })).toBe(false);
+        });
+        it('should return false when the value is not a string, array, or object', function () {
+            expect(isEmpty(1)).toBe(false);
+            expect(isEmpty(null)).toBe(false);
+            expect(isEmpty(undefined)).toBe(false);
+        });
+    });
+});