@wise/dynamic-flow-client 0.2.0 → 0.2.1

package/build/common/validation/valid-model/spec.js

@@ -1,605 +0,0 @@
-import { getValidModelParts } from '.';
-describe('Given a library for returning the valid parts of a model based on a schema', function () {
-    describe('when cleaning a string schema', function () {
-        var schema = { type: 'string' };
-        describe('with a string model', function () {
-            it('should return the original string', function () {
-                var result = getValidModelParts('string', schema);
-                expect(result).toBe('string');
-            });
-        });
-        describe('with a non string model', function () {
-            it('should return null', function () {
-                expect(getValidModelParts(null, schema)).toBeNull();
-                expect(getValidModelParts(123, schema)).toBeNull();
-                expect(getValidModelParts(true, schema)).toBeNull();
-                expect(getValidModelParts(false, schema)).toBeNull();
-                expect(getValidModelParts([123, 456], schema)).toBeNull();
-                expect(getValidModelParts(['a', 'b'], schema)).toBeNull();
-                expect(getValidModelParts([true, false], schema)).toBeNull();
-                expect(getValidModelParts({ a: 1 }, schema)).toBeNull();
-            });
-        });
-    });
-    describe('when cleaning a number schema', function () {
-        var schema = { type: 'number' };
-        describe('with an integer model', function () {
-            it('should return the original integer', function () {
-                var result = getValidModelParts(12345, schema);
-                expect(result).toBe(12345);
-            });
-        });
-        describe('with any float model', function () {
-            it('should return the original model', function () {
-                var result = getValidModelParts(12.34, schema);
-                expect(result).toBe(12.34);
-            });
-        });
-        describe('with any non number model', function () {
-            it('should return null', function () {
-                expect(getValidModelParts(null, schema)).toBeNull();
-                expect(getValidModelParts('abc', schema)).toBeNull();
-                expect(getValidModelParts(true, schema)).toBeNull();
-                expect(getValidModelParts(false, schema)).toBeNull();
-                expect(getValidModelParts([123, 456], schema)).toBeNull();
-                expect(getValidModelParts(['a', 'b'], schema)).toBeNull();
-                expect(getValidModelParts([true, false], schema)).toBeNull();
-                expect(getValidModelParts({ a: 1 }, schema)).toBeNull();
-            });
-        });
-    });
-    describe('when cleaning an integer schema', function () {
-        var schema = { type: 'integer' };
-        describe('with an integer model', function () {
-            it('should return the original integer', function () {
-                var result = getValidModelParts(12345, schema);
-                expect(result).toBe(12345);
-            });
-        });
-        describe('with any float model', function () {
-            it('should return the original model', function () {
-                var result = getValidModelParts(12.34, schema);
-                expect(result).toBe(12.34);
-            });
-        });
-        describe('with any non number model', function () {
-            it('should return null', function () {
-                expect(getValidModelParts(null, schema)).toBeNull();
-                expect(getValidModelParts('abc', schema)).toBeNull();
-                expect(getValidModelParts(true, schema)).toBeNull();
-                expect(getValidModelParts(false, schema)).toBeNull();
-                expect(getValidModelParts([123, 456], schema)).toBeNull();
-                expect(getValidModelParts(['a', 'b'], schema)).toBeNull();
-                expect(getValidModelParts([true, false], schema)).toBeNull();
-                expect(getValidModelParts({ a: 1 }, schema)).toBeNull();
-            });
-        });
-    });
-    describe('when cleaning a boolean schema', function () {
-        var schema = { type: 'boolean' };
-        describe('with a boolean model', function () {
-            it('should return the original boolean', function () {
-                expect(getValidModelParts(true, schema)).toBe(true);
-                expect(getValidModelParts(false, schema)).toBe(false);
-            });
-        });
-        describe('with any non boolean model', function () {
-            it('should return null', function () {
-                expect(getValidModelParts(null, schema)).toBeNull();
-                expect(getValidModelParts('abc', schema)).toBeNull();
-                expect(getValidModelParts(123, schema)).toBeNull();
-                expect(getValidModelParts([123, 456], schema)).toBeNull();
-                expect(getValidModelParts(['a', 'b'], schema)).toBeNull();
-                expect(getValidModelParts([true, false], schema)).toBeNull();
-                expect(getValidModelParts({ a: 1 }, schema)).toBeNull();
-            });
-        });
-    });
-    describe('when cleaning a const schema', function () {
-        describe('when the const is a number', function () {
-            var schema = { "const": 1 };
-            describe('if the model matches the const', function () {
-                it('should return the original model', function () {
-                    var result = getValidModelParts(1, schema);
-                    expect(result).toBe(1);
-                });
-            });
-            describe('if the model does not match the const', function () {
-                it('should return null', function () {
-                    expect(getValidModelParts(2, schema)).toBeNull();
-                    expect(getValidModelParts(null, schema)).toBeNull();
-                    expect(getValidModelParts('abc', schema)).toBeNull();
-                    expect(getValidModelParts(true, schema)).toBeNull();
-                    expect(getValidModelParts(false, schema)).toBeNull();
-                    expect(getValidModelParts([123, 456], schema)).toBeNull();
-                    expect(getValidModelParts(['one', 'two'], schema)).toBeNull();
-                    expect(getValidModelParts([true, false], schema)).toBeNull();
-                    expect(getValidModelParts({ a: 1 }, schema)).toBeNull();
-                });
-            });
-            describe('if the const evaluates to false', function () {
-                it('should still return matches', function () {
-                    var result = getValidModelParts(0, { "const": 0 });
-                    expect(result).toBe(0);
-                });
-            });
-        });
-        describe('when the const is a string', function () {
-            var schema = { "const": 'one' };
-            describe('if the model matches the const', function () {
-                it('should return the original model', function () {
-                    var result = getValidModelParts('one', schema);
-                    expect(result).toBe('one');
-                });
-            });
-            describe('if the model does not match the const', function () {
-                it('should return null', function () {
-                    expect(getValidModelParts('two', schema)).toBeNull();
-                    expect(getValidModelParts(null, schema)).toBeNull();
-                    expect(getValidModelParts(123, schema)).toBeNull();
-                    expect(getValidModelParts(true, schema)).toBeNull();
-                    expect(getValidModelParts(false, schema)).toBeNull();
-                    expect(getValidModelParts([123, 456], schema)).toBeNull();
-                    expect(getValidModelParts(['one', 'two'], schema)).toBeNull();
-                    expect(getValidModelParts([true, false], schema)).toBeNull();
-                    expect(getValidModelParts({ a: 1 }, schema)).toBeNull();
-                });
-            });
-            describe('if the const evaluates to false', function () {
-                it('should still return matches', function () {
-                    var result = getValidModelParts('', { "const": '' });
-                    expect(result).toBe('');
-                });
-            });
-        });
-        describe('when the const is a boolean', function () {
-            var schema = { "const": true };
-            describe('if the model matches the const', function () {
-                it('should return the original model', function () {
-                    var result = getValidModelParts(true, schema);
-                    expect(result).toBe(true);
-                });
-            });
-            describe('if the model does not match the const', function () {
-                it('should return null', function () {
-                    expect(getValidModelParts(false, schema)).toBeNull();
-                    expect(getValidModelParts('abc', schema)).toBeNull();
-                    expect(getValidModelParts(null, schema)).toBeNull();
-                    expect(getValidModelParts(123, schema)).toBeNull();
-                    expect(getValidModelParts([123, 456], schema)).toBeNull();
-                    expect(getValidModelParts(['one', 'two'], schema)).toBeNull();
-                    expect(getValidModelParts([true, false], schema)).toBeNull();
-                    expect(getValidModelParts({ a: 1 }, schema)).toBeNull();
-                });
-            });
-            describe('if the const evaluates to false', function () {
-                it('should still return matches', function () {
-                    var result = getValidModelParts(false, { "const": false });
-                    expect(result).toBe(false);
-                });
-            });
-        });
-    });
-    describe('when cleaning a simple object schema', function () {
-        var schema = {
-            type: 'object',
-            properties: {
-                a: {
-                    type: 'number'
-                }
-            },
-            displayOrder: ['a']
-        };
-        describe('if the model has a property with the correct name and the correct type', function () {
-            it('should return the property', function () {
-                var result = getValidModelParts({ a: 1 }, schema);
-                expect(result).toStrictEqual({ a: 1 });
-            });
-        });
-        describe('if the model has a property with the correct name but an incorrect type', function () {
-            it('should return an empty object', function () {
-                var result = getValidModelParts({ a: 'one' }, schema);
-                expect(result).toStrictEqual({});
-            });
-        });
-        describe('if the model contains properties not in the schema', function () {
-            it('should return the object without those properties', function () {
-                var result = getValidModelParts({ a: 1, b: 2 }, schema);
-                expect(result).toStrictEqual({ a: 1 });
-            });
-        });
-        describe('if the model is not an object', function () {
-            it('should return null', function () {
-                expect(getValidModelParts(false, schema)).toBeNull();
-                expect(getValidModelParts('abc', schema)).toBeNull();
-                expect(getValidModelParts(null, schema)).toBeNull();
-                expect(getValidModelParts(123, schema)).toBeNull();
-                expect(getValidModelParts([123, 456], schema)).toBeNull();
-                expect(getValidModelParts(['one', 'two'], schema)).toBeNull();
-                expect(getValidModelParts([true, false], schema)).toBeNull();
-            });
-        });
-    });
-    describe('when cleaning an object schema with nested objects', function () {
-        var schema = {
-            type: 'object',
-            properties: {
-                a: {
-                    type: 'number'
-                },
-                b: {
-                    type: 'object',
-                    properties: {
-                        c: {
-                            type: 'number'
-                        }
-                    },
-                    displayOrder: ['c']
-                }
-            },
-            displayOrder: ['a', 'b']
-        };
-        describe('if the nested model is valid', function () {
-            it('should be returned', function () {
-                var result = getValidModelParts({ a: 1, b: { c: 2 } }, schema);
-                expect(result).toStrictEqual({ a: 1, b: { c: 2 } });
-            });
-        });
-        describe('if the nested model contains invalid properties', function () {
-            it('should remove them', function () {
-                var result = getValidModelParts({ a: 1, b: { c: 2, d: 3 }, e: 4 }, schema);
-                expect(result).toStrictEqual({ a: 1, b: { c: 2 } });
-            });
-        });
-    });
-    describe('when cleaning a oneOf schema of object schemas', function () {
-        var schema = {
-            oneOf: [
-                {
-                    type: 'object',
-                    properties: {
-                        a: {
-                            type: 'number'
-                        }
-                    },
-                    displayOrder: ['a']
-                },
-                {
-                    type: 'object',
-                    properties: {
-                        b: {
-                            type: 'number'
-                        }
-                    },
-                    displayOrder: ['b']
-                },
-            ]
-        };
-        describe('if all of the properties are valid', function () {
-            it('should return them', function () {
-                var result = getValidModelParts({ a: 1, b: 2 }, schema);
-                expect(result).toStrictEqual({ a: 1, b: 2 });
-            });
-        });
-        describe('if the nested model contains invalid properties', function () {
-            it('should remove them', function () {
-                var result = getValidModelParts({ a: 1, b: 'two' }, schema);
-                expect(result).toStrictEqual({ a: 1 });
-            });
-        });
-        describe('if the nested model contains ALL invalid properties', function () {
-            it('should remove them', function () {
-                var result = getValidModelParts({ a: 'one', b: 'two' }, schema);
-                expect(result).toStrictEqual({});
-            });
-        });
-        describe('if the model contains undocumented properties', function () {
-            it('should remove them', function () {
-                var result = getValidModelParts({ a: 1, b: 2, c: 3 }, schema);
-                expect(result).toStrictEqual({ a: 1, b: 2 });
-            });
-        });
-        describe('if the model is not an object', function () {
-            it('should return null', function () {
-                expect(getValidModelParts(false, schema)).toBeNull();
-                expect(getValidModelParts('abc', schema)).toBeNull();
-                expect(getValidModelParts(null, schema)).toBeNull();
-                expect(getValidModelParts(123, schema)).toBeNull();
-                expect(getValidModelParts([123, 456], schema)).toBeNull();
-                expect(getValidModelParts(['one', 'two'], schema)).toBeNull();
-                expect(getValidModelParts([true, false], schema)).toBeNull();
-            });
-        });
-    });
-    describe('when cleaning a oneOf schema of const', function () {
-        describe('when the consts are numbers', function () {
-            var schema = {
-                oneOf: [{ "const": 0 }, { "const": 1 }, { "const": 2 }]
-            };
-            describe('when the value is in the const collection', function () {
-                it('should return the value', function () {
-                    expect(getValidModelParts(0, schema)).toBe(0);
-                    expect(getValidModelParts(1, schema)).toBe(1);
-                    expect(getValidModelParts(2, schema)).toBe(2);
-                });
-            });
-            describe('when the value is not in the const collection', function () {
-                it('should return null', function () {
-                    expect(getValidModelParts(3, schema)).toBeNull();
-                    expect(getValidModelParts(null, schema)).toBeNull();
-                    expect(getValidModelParts(true, schema)).toBeNull();
-                    expect(getValidModelParts(false, schema)).toBeNull();
-                    expect(getValidModelParts('abc', schema)).toBeNull();
-                    expect(getValidModelParts(123, schema)).toBeNull();
-                    expect(getValidModelParts([123, 456], schema)).toBeNull();
-                    expect(getValidModelParts(['one', 'two'], schema)).toBeNull();
-                    expect(getValidModelParts([true, false], schema)).toBeNull();
-                    expect(getValidModelParts({}, schema)).toBeNull();
-                });
-            });
-        });
-        describe('when the consts are strings', function () {
-            var schema = {
-                oneOf: [{ "const": 'zero' }, { "const": 'one' }, { "const": 'two' }]
-            };
-            describe('when the value is in the const collection', function () {
-                it('should return the value', function () {
-                    expect(getValidModelParts('zero', schema)).toBe('zero');
-                    expect(getValidModelParts('one', schema)).toBe('one');
-                    expect(getValidModelParts('two', schema)).toBe('two');
-                });
-            });
-            describe('when the value is not in the const collection', function () {
-                it('should return null', function () {
-                    expect(getValidModelParts('three', schema)).toBeNull();
-                    expect(getValidModelParts(null, schema)).toBeNull();
-                    expect(getValidModelParts(true, schema)).toBeNull();
-                    expect(getValidModelParts(false, schema)).toBeNull();
-                    expect(getValidModelParts(123, schema)).toBeNull();
-                    expect(getValidModelParts([123, 456], schema)).toBeNull();
-                    expect(getValidModelParts(['one', 'two'], schema)).toBeNull();
-                    expect(getValidModelParts([true, false], schema)).toBeNull();
-                    expect(getValidModelParts({}, schema)).toBeNull();
-                });
-            });
-        });
-        describe('when the consts are booleans', function () {
-            var schema = {
-                oneOf: [{ "const": false }, { "const": true }]
-            };
-            describe('when the value is in the const collection', function () {
-                it('should return the value', function () {
-                    expect(getValidModelParts(false, schema)).toBe(false);
-                    expect(getValidModelParts(true, schema)).toBe(true);
-                });
-            });
-            describe('when the value is not in the const collection', function () {
-                it('should return null', function () {
-                    expect(getValidModelParts(null, schema)).toBeNull();
-                    expect(getValidModelParts('abc', schema)).toBeNull();
-                    expect(getValidModelParts(123, schema)).toBeNull();
-                    expect(getValidModelParts([123, 456], schema)).toBeNull();
-                    expect(getValidModelParts(['one', 'two'], schema)).toBeNull();
-                    expect(getValidModelParts([true, false], schema)).toBeNull();
-                    expect(getValidModelParts({}, schema)).toBeNull();
-                });
-            });
-        });
-    });
-    describe('when cleaning a oneOf schema of array schemas', function () {
-        var schema = {
-            oneOf: [
-                {
-                    type: 'array',
-                    items: { type: 'string' }
-                },
-                {
-                    type: 'array',
-                    items: { type: 'number' }
-                },
-            ]
-        };
-        describe('when the model is valid for one of the one-ofs', function () {
-            it('should return the model', function () {
-                expect(getValidModelParts(['a', 'b', 'c'], schema)).toStrictEqual(['a', 'b', 'c']);
-                expect(getValidModelParts([1, 2, 3], schema)).toStrictEqual([1, 2, 3]);
-            });
-        });
-        describe('when the model is NOT valid for any of the one-ofs', function () {
-            it('should return null', function () {
-                expect(getValidModelParts([true, false, true], schema)).toStrictEqual([null, null, null]);
-                expect(getValidModelParts(['a', 'b', 123], schema)).toStrictEqual([null, null, null]);
-                expect(getValidModelParts([123, 456, 'abc'], schema)).toStrictEqual([null, null, null]);
-                expect(getValidModelParts(null, schema)).toBeNull();
-                expect(getValidModelParts('abc', schema)).toBeNull();
-                expect(getValidModelParts(123, schema)).toBeNull();
-                expect(getValidModelParts({ a: 1 }, schema)).toBeNull();
-            });
-        });
-    });
-    describe('when cleaning an allOf schema of object schemas', function () {
-        var schema = {
-            allOf: [
-                {
-                    type: 'object',
-                    properties: {
-                        a: {
-                            type: 'number'
-                        }
-                    },
-                    displayOrder: ['a']
-                },
-                {
-                    type: 'object',
-                    properties: {
-                        b: {
-                            type: 'number'
-                        }
-                    },
-                    displayOrder: ['b']
-                },
-            ]
-        };
-        describe('if all of the properties are valid', function () {
-            it('should return them', function () {
-                var result = getValidModelParts({ a: 1, b: 2 }, schema);
-                expect(result).toStrictEqual({ a: 1, b: 2 });
-            });
-        });
-        describe('if the model contains invalid properties', function () {
-            it('should remove them', function () {
-                var result = getValidModelParts({ a: 1, b: '2' }, schema);
-                expect(result).toStrictEqual({ a: 1 });
-            });
-        });
-        describe('if the model contains undocumented properties', function () {
-            it('should remove them', function () {
-                var result = getValidModelParts({ a: 1, b: 2, c: 3 }, schema);
-                expect(result).toStrictEqual({ a: 1, b: 2 });
-            });
-        });
-        describe('if the models is not an object', function () {
-            it('should return null', function () {
-                expect(getValidModelParts(null, schema)).toBeNull();
-                expect(getValidModelParts(true, schema)).toBeNull();
-                expect(getValidModelParts(false, schema)).toBeNull();
-                expect(getValidModelParts('abc', schema)).toBeNull();
-                expect(getValidModelParts(123, schema)).toBeNull();
-                expect(getValidModelParts(['a', 'b', 123], schema)).toBeNull();
-                expect(getValidModelParts([true, false], schema)).toBeNull();
-            });
-        });
-    });
-    describe('when schemas both contain the same nested object', function () {
-        var schema = {
-            oneOf: [
-                {
-                    type: 'object',
-                    properties: {
-                        nested: {
-                            type: 'object',
-                            properties: {
-                                a: { type: 'string' }
-                            },
-                            displayOrder: ['a']
-                        }
-                    },
-                    displayOrder: ['nested']
-                },
-                {
-                    type: 'object',
-                    properties: {
-                        nested: {
-                            type: 'object',
-                            properties: {
-                                b: { type: 'string' }
-                            },
-                            displayOrder: ['b']
-                        }
-                    },
-                    displayOrder: ['nested']
-                },
-            ]
-        };
-        it('should deep merge the content of the nested objects', function () {
-            var model = { nested: { a: 'one', b: 'two' } };
-            var result = getValidModelParts(model, schema);
-            expect(result).toStrictEqual(model);
-        });
-    });
-    describe('when cleaning file array schema', function () {
-        var schema = {
-            type: 'array',
-            items: {
-                type: 'string',
-                persistAsync: {
-                    url: 'http://localhost:3001/v1/save-file/',
-                    method: 'POST',
-                    param: 'bodyAttribute',
-                    idProperty: 'responseKey',
-                    schema: {
-                        type: 'string',
-                        format: 'base64url',
-                        maxSize: 5242000,
-                        title: 'Invoice (optional)'
-                    }
-                }
-            }
-        };
-        it('should deep merge the content of the nested objects', function () {
-            var result = getValidModelParts(['file-123', 'file-234'], schema);
-            expect(result).toStrictEqual(['file-123', 'file-234']);
-        });
-    });
-    describe('when cleaning an array schema of number schemas', function () {
-        var schema = {
-            type: 'array',
-            items: { type: 'number' }
-        };
-        describe('when the model is an array of numbers', function () {
-            var model = [1, 2, 3];
-            it('should return the model', function () {
-                var result = getValidModelParts(model, schema);
-                expect(result).toStrictEqual(model);
-            });
-        });
-        describe('when the model is NOT and array of numbers', function () {
-            it('should return null', function () {
-                expect(getValidModelParts(['a', 'b', 'c'], schema)).toStrictEqual([null, null, null]);
-                expect(getValidModelParts([true, false], schema)).toStrictEqual([null, null]);
-                expect(getValidModelParts(['a', 'b', 123], schema)).toStrictEqual([null, null, null]);
-                expect(getValidModelParts(null, schema)).toBeNull();
-                expect(getValidModelParts('abc', schema)).toBeNull();
-                expect(getValidModelParts(123, schema)).toBeNull();
-                expect(getValidModelParts({ a: 1 }, schema)).toBeNull();
-            });
-        });
-    });
-    describe('when cleaning an array schema of string schemas', function () {
-        var schema = {
-            type: 'array',
-            items: { type: 'string' }
-        };
-        describe('when the model is an array of strings', function () {
-            var model = ['a', 'b', 'c'];
-            it('should return the model', function () {
-                var result = getValidModelParts(model, schema);
-                expect(result).toStrictEqual(model);
-            });
-        });
-        describe('when the model is NOT and array of strings', function () {
-            it('should return null', function () {
-                expect(getValidModelParts(['a', 'b', 123], schema)).toStrictEqual([null, null, null]);
-                expect(getValidModelParts([true, false], schema)).toStrictEqual([null, null]);
-                expect(getValidModelParts([1, 2, 3], schema)).toStrictEqual([null, null, null]);
-                expect(getValidModelParts(null, schema)).toBeNull();
-                expect(getValidModelParts('abc', schema)).toBeNull();
-                expect(getValidModelParts(123, schema)).toBeNull();
-                expect(getValidModelParts({ a: 1 }, schema)).toBeNull();
-            });
-        });
-    });
-    describe('when cleaning an array schema of boolean schemas', function () {
-        var schema = {
-            type: 'array',
-            items: { type: 'boolean' }
-        };
-        describe('when the model is an array of booleans', function () {
-            var model = [true, false, true];
-            it('should return the model', function () {
-                var result = getValidModelParts(model, schema);
-                expect(result).toStrictEqual(model);
-            });
-        });
-        describe('when the model is NOT and array of booleans', function () {
-            it('should return null', function () {
-                expect(getValidModelParts(['a', 'b', 123], schema)).toStrictEqual([null, null, null]);
-                expect(getValidModelParts([1, 2, 3], schema)).toStrictEqual([null, null, null]);
-                expect(getValidModelParts(null, schema)).toBeNull();
-                expect(getValidModelParts('abc', schema)).toBeNull();
-                expect(getValidModelParts(123, schema)).toBeNull();
-                expect(getValidModelParts({ a: 1 }, schema)).toBeNull();
-            });
-        });
-    });
-});

package/build/common/validation/validation-failures/spec.d.ts

@@ -1 +0,0 @@
-export {};