@fincity/kirun-js 1.5.2 → 1.6.3

package/__tests__/engine/json/schema/validator/ArrayContainsValidatorTest.ts

@@ -0,0 +1,339 @@
+import {
+    ArraySchemaType,
+    ArrayValidator,
+    isNullValue,
+    KIRunSchemaRepository,
+    Schema,
+    SchemaType,
+    Type,
+    TypeUtil,
+} from '../../../../../src';
+
+const repo = new KIRunSchemaRepository();
+
+test('schema array contains test  ', () => {
+    let tupleS: Schema[] = [
+        Schema.ofString('item1'),
+        Schema.ofInteger('item2'),
+        Schema.ofObject('item3'),
+    ];
+
+    let ast: ArraySchemaType = new ArraySchemaType();
+    ast.setTupleSchema(tupleS);
+
+    let schema: Schema = Schema.ofArray('arraySchema')
+        .setItems(ast)
+        .setContains(Schema.ofObject('containsS'));
+
+    let obj = {
+        val: false,
+    };
+
+    let array: any[] = ['jimmy', 31, obj];
+
+    expect(ArrayValidator.validate([], schema, repo, array)).toStrictEqual(array);
+});
+
+test('schema array error contains test  ', () => {
+    let tupleS: Schema[] = [
+        Schema.ofString('item1'),
+        Schema.ofInteger('item2'),
+        Schema.ofObject('item3'),
+    ];
+
+    let ast: ArraySchemaType = new ArraySchemaType();
+    ast.setTupleSchema(tupleS);
+
+    let schema: Schema = Schema.ofArray('arraySchema')
+        .setItems(ast)
+        .setContains(Schema.ofBoolean('containsS'));
+
+    let obj = {
+        val: false,
+    };
+
+    let array: any[] = ['jimmy', 31, obj];
+
+    expect(() => ArrayValidator.validate([], schema, repo, array)).toThrow(
+        'None of the items are of type contains schema',
+    );
+});
+
+test('schema array min contains test  ', () => {
+    let tupleS: Schema[] = [
+        Schema.ofString('item1'),
+        Schema.ofInteger('item2'),
+        Schema.ofObject('item3'),
+        Schema.ofBoolean('item4'),
+        Schema.ofObject('item5'),
+    ];
+
+    let ast: ArraySchemaType = new ArraySchemaType();
+    ast.setTupleSchema(tupleS);
+
+    let schema: Schema = Schema.ofArray('arraySchema')
+        .setItems(ast)
+        .setContains(Schema.ofObject('containsS'))
+        .setMinContains(2);
+
+    let obj = {
+        val: false,
+    };
+    let obj1 = {
+        name: 'mcgill',
+    };
+
+    let array: any[] = ['jimmy', 31, obj, true, obj1];
+
+    expect(ArrayValidator.validate([], schema, repo, array)).toStrictEqual(array);
+});
+
+test('schema array max contains test  ', () => {
+    let tupleS: Schema[] = [
+        Schema.ofString('item1'),
+        Schema.ofInteger('item2'),
+        Schema.ofObject('item3'),
+        Schema.ofBoolean('item4'),
+        Schema.ofObject('item5'),
+    ];
+
+    let ast: ArraySchemaType = new ArraySchemaType();
+    ast.setTupleSchema(tupleS);
+
+    let schema: Schema = Schema.ofArray('arraySchema')
+        .setItems(ast)
+        .setContains(Schema.ofObject('containsS'))
+        .setMaxContains(3);
+
+    let obj = {
+        val: false,
+    };
+    let obj1 = {
+        name: 'mcgill',
+    };
+
+    let array: any[] = ['jimmy', 31, obj, true, obj1];
+
+    expect(ArrayValidator.validate([], schema, repo, array)).toStrictEqual(array);
+});
+
+test('schema array min contains test  ', () => {
+    let tupleS: Schema[] = [
+        Schema.ofString('item1'),
+        Schema.ofInteger('item2'),
+        Schema.ofObject('item3'),
+        Schema.ofBoolean('item4'),
+        Schema.ofObject('item5'),
+    ];
+
+    let ast: ArraySchemaType = new ArraySchemaType();
+    ast.setTupleSchema(tupleS);
+
+    let schema: Schema = Schema.ofArray('arraySchema')
+        .setItems(ast)
+        .setContains(Schema.ofObject('containsS'))
+        .setMinContains(4);
+
+    let obj = {
+        val: false,
+    };
+    let obj1 = {
+        name: 'mcgill',
+    };
+
+    let array: any[] = ['jimmy', 31, obj, true, obj1];
+
+    expect(() => ArrayValidator.validate([], schema, repo, array)).toThrow(
+        'The minimum number of the items of type contains schema should be ' +
+            schema.getMinContains() +
+            ' but found 2',
+    );
+});
+
+test('schema array max contains test  ', () => {
+    let tupleS: Schema[] = [
+        Schema.ofString('item1'),
+        Schema.ofInteger('item2'),
+        Schema.ofObject('item3'),
+        Schema.ofBoolean('item4'),
+        Schema.ofObject('item5'),
+    ];
+
+    let ast: ArraySchemaType = new ArraySchemaType();
+    ast.setTupleSchema(tupleS);
+
+    let schema: Schema = Schema.ofArray('arraySchema')
+        .setItems(ast)
+        .setContains(Schema.ofObject('containsS'))
+        .setMaxContains(1);
+
+    let obj = {
+        val: false,
+    };
+    let obj1 = {
+        name: 'mcgill',
+    };
+
+    let array: any[] = ['jimmy', 31, obj, true, obj1];
+
+    expect(() => ArrayValidator.validate([], schema, repo, array)).toThrow(
+        'The maximum number of the items of type contains schema should be ' +
+            schema.getMaxContains() +
+            ' but found 2',
+    );
+});
+
+test('schema array min error contains test  ', () => {
+    let tupleS: Schema[] = [
+        Schema.ofString('item1'),
+        Schema.ofInteger('item2'),
+        Schema.ofObject('item3'),
+        Schema.ofBoolean('item4'),
+        Schema.ofObject('item5'),
+    ];
+
+    let ast: ArraySchemaType = new ArraySchemaType();
+    ast.setTupleSchema(tupleS);
+
+    let schema: Schema = Schema.ofArray('arraySchema')
+        .setItems(ast)
+        .setContains(Schema.ofObject('containsS'))
+        .setMinContains(4);
+
+    let obj = {
+        val: false,
+    };
+    let obj1 = {
+        name: 'mcgill',
+    };
+
+    let array: any[] = ['jimmy', 31, obj, true, obj1];
+
+    expect(() => ArrayValidator.validate([], schema, repo, array)).toThrow(
+        'The minimum number of the items of type contains schema should be ' +
+            schema.getMinContains() +
+            ' but found 2',
+    );
+});
+
+test('schema array min max contains test  ', () => {
+    let tupleS: Schema[] = [
+        Schema.ofString('item1'),
+        Schema.ofInteger('item2'),
+        Schema.ofObject('item3'),
+        Schema.ofBoolean('item4'),
+        Schema.ofObject('item5'),
+    ];
+
+    let ast: ArraySchemaType = new ArraySchemaType();
+    ast.setTupleSchema(tupleS);
+
+    let schema: Schema = Schema.ofArray('arraySchema')
+        .setItems(ast)
+        .setContains(Schema.ofObject('containsS'))
+        .setMinContains(1)
+        .setMaxContains(3);
+
+    let obj = {
+        val: false,
+    };
+    let obj1 = {
+        name: 'mcgill',
+    };
+
+    let array: any[] = ['jimmy', 31, obj, true, obj1];
+
+    expect(ArrayValidator.validate([], schema, repo, array)).toBe(array);
+});
+
+test('schema array min max contains test  ', () => {
+    let tupleS: Schema[] = [
+        Schema.ofString('item1'),
+        Schema.ofInteger('item2'),
+        Schema.ofObject('item3'),
+        Schema.ofBoolean('item4'),
+        Schema.ofObject('item5'),
+    ];
+
+    let ast: ArraySchemaType = new ArraySchemaType();
+    ast.setTupleSchema(tupleS);
+
+    let schema: Schema = Schema.ofArray('arraySchema')
+        .setItems(ast)
+        .setContains(Schema.ofObject('containsS'))
+        .setMinContains(1)
+        .setMaxContains(0);
+
+    let obj = {
+        val: false,
+    };
+    let obj1 = {
+        name: 'mcgill',
+    };
+
+    let array: any[] = ['jimmy', 31, obj, true, obj1];
+
+    expect(() => ArrayValidator.validate([], schema, repo, array)).toThrow(
+        'The maximum number of the items of type contains schema should be ' +
+            schema.getMaxContains() +
+            ' but found 2',
+    );
+});
+
+test('schema array min max contains without contains test  ', () => {
+    let tupleS: Schema[] = [
+        Schema.ofString('item1'),
+        Schema.ofInteger('item2'),
+        Schema.ofObject('item3'),
+        Schema.ofBoolean('item4'),
+        Schema.ofObject('item5'),
+    ];
+
+    let ast: ArraySchemaType = new ArraySchemaType();
+    ast.setTupleSchema(tupleS);
+
+    let schema: Schema = Schema.ofArray('arraySchema')
+        .setItems(ast)
+        .setMinContains(5)
+        .setMaxContains(45);
+
+    let obj = {
+        val: false,
+    };
+    let obj1 = {
+        name: 'mcgill',
+    };
+
+    let array: any[] = ['jimmy', 31, obj, true, obj1];
+
+    expect(ArrayValidator.validate([], schema, repo, array)).toBe(array);
+});
+
+test('schema array min max contains without contains test  ', () => {
+    let tupleS: Schema[] = [
+        Schema.ofString('item1'),
+        Schema.ofInteger('item2'),
+        Schema.ofObject('item3'),
+        Schema.ofBoolean('item4'),
+        Schema.ofObject('item5'),
+    ];
+
+    let ast: ArraySchemaType = new ArraySchemaType();
+    ast.setTupleSchema(tupleS);
+
+    let schema: Schema = Schema.ofArray('arraySchema')
+        .setItems(ast)
+        .setMinContains(1)
+        .setMaxContains(0);
+
+    let obj = {
+        val: false,
+    };
+    let obj1 = {
+        name: 'mcgill',
+    };
+
+    let array: any[] = ['jimmy', 31, obj, true, obj1];
+
+    expect(ArrayValidator.validate([], schema, repo, array)).toBe(array);
+});

package/__tests__/engine/json/schema/validator/ArraySchemaAdapterTypeTest.ts

@@ -0,0 +1,142 @@
+import { KIRunSchemaRepository, SchemaValidator } from '../../../../../src';
+import { Schema } from '../../../../../src/engine/json/schema/Schema';
+
+const repo = new KIRunSchemaRepository();
+test('schemaArray With Single Test', () => {
+    let schema = Schema.from({
+        type: 'ARRAY',
+        items: {
+            singleSchema: {
+                type: 'OBJECT',
+                properties: { name: { type: 'STRING' }, age: { type: 'INTEGER' } },
+            },
+        },
+        additionalItems: false,
+    });
+
+    let obj = [
+        {
+            name: 'amigo1',
+        },
+        {
+            age: 24,
+        },
+        false,
+        'exampleString',
+    ];
+
+    expect(() => SchemaValidator.validate([], schema, repo, obj)).toThrow();
+});
+
+test('schemaArray With out Single fail Test', () => {
+    let schema = Schema.from({
+        type: 'ARRAY',
+        items: {
+            type: 'OBJECT',
+            properties: { name: { type: 'STRING' }, age: { type: 'INTEGER' } },
+        },
+
+        additionalItems: false,
+    });
+
+    let obj = [
+        {
+            name: 'amigo1',
+        },
+        {
+            age: 24,
+        },
+        false,
+        'exampleString',
+    ];
+
+    expect(() => SchemaValidator.validate([], schema, repo, obj)).toThrow();
+});
+
+test('schemaArrayWithSingle pass Test', () => {
+    let schema = Schema.from({
+        type: 'ARRAY',
+        items: {
+            singleSchema: {
+                type: 'OBJECT',
+                properties: { name: { type: 'STRING' }, age: { type: 'INTEGER' } },
+            },
+        },
+
+        additionalItems: false,
+    });
+
+    let obj = [
+        {
+            name: 'amigo1',
+        },
+        {
+            age: 24,
+        },
+    ];
+
+    expect(SchemaValidator.validate([], schema, repo, obj)).toBe(obj);
+});
+
+test('schemaArray With Tuple Test ', () => {
+    let schema = Schema.from({
+        type: 'ARRAY',
+        items: {
+            tupleSchema: [
+                {
+                    type: 'OBJECT',
+                    properties: { name: { type: 'STRING' }, age: { type: 'INTEGER' } },
+                    required: ['age'],
+                },
+                { type: 'STRING', minLength: 2 },
+                { type: 'INTEGER', minimum: 10 },
+            ],
+        },
+        additionalItems: true,
+    });
+
+    let obj = [
+        {
+            name: 'amigo1',
+            age: 24,
+        },
+        'string type',
+
+        11,
+        false,
+        12.34,
+        'mla',
+    ];
+    console.log(JSON.stringify(schema, undefined, 2));
+
+    expect(SchemaValidator.validate([], schema, repo, obj)).toBe(obj);
+});
+
+test('schemaArray With out Tuple Test ', () => {
+    let schema = Schema.from({
+        type: 'ARRAY',
+        items: [
+            {
+                type: 'OBJECT',
+                properties: { name: { type: 'STRING' }, age: { type: 'INTEGER' } },
+                required: ['age'],
+            },
+            { type: 'STRING', minLength: 2 },
+            { type: 'ARRAY', items: { type: 'INTEGER' }, additionalItems: false },
+        ],
+        additionalItems: true,
+    });
+
+    let obj = [
+        {
+            name: 'amigo1',
+            age: 21,
+        },
+        'second string',
+        [1, 2, 31231],
+        'additional items was added here with true and false',
+        true,
+        false,
+    ];
+    expect(SchemaValidator.validate([], schema, repo, obj)).toBe(obj);
+});

package/__tests__/engine/json/schema/validator/ArraySchemaTypeTest.ts

@@ -0,0 +1,191 @@
+import {
+    AdditionalType,
+    ArraySchemaType,
+    ArrayValidator,
+    KIRunSchemaRepository,
+    Schema,
+    SchemaValidator,
+} from '../../../../../src';
+
+const repo = new KIRunSchemaRepository();
+
+test('schema array validator test for single', () => {
+    let ast = new ArraySchemaType();
+    ast.setSingleSchema(Schema.ofInteger('ast'));
+
+    const schema: Schema = Schema.ofArray('schema').setItems(ast);
+
+    let arr = [12, 23, 54, 45];
+
+    expect(ArrayValidator.validate([], schema, repo, arr)).toStrictEqual(arr);
+});
+
+test('schema array validator test for tuple', () => {
+    let tupleS: Schema[] = [
+        Schema.ofInteger('item1'),
+        Schema.ofString('item2'),
+        Schema.ofObject('item3'),
+    ];
+
+    let ast = new ArraySchemaType();
+    ast.setTupleSchema(tupleS);
+
+    const schema: Schema = Schema.ofArray('schema').setItems(ast);
+
+    let arr = [12, 'surendhar', { a: 'val1', b: 'val2' }];
+
+    expect(ArrayValidator.validate([], schema, repo, arr)).toStrictEqual(arr);
+});
+
+test('schema array validator test for single', () => {
+    let ast = new ArraySchemaType();
+    ast.setSingleSchema(Schema.ofInteger('ast'));
+
+    const schema: Schema = Schema.ofArray('schema')
+        .setItems(ast)
+        .setAdditionalItems(new AdditionalType().setBooleanValue(false));
+
+    let arr = [12, 23, 54, 45];
+
+    expect(ArrayValidator.validate([], schema, repo, arr)).toStrictEqual(arr);
+});
+
+test('schema array validator test for tuple', () => {
+    let tupleS: Schema[] = [
+        Schema.ofInteger('item1'),
+        Schema.ofString('item2'),
+        Schema.ofObject('item3'),
+    ];
+
+    let ast = new ArraySchemaType();
+    ast.setTupleSchema(tupleS);
+
+    const schema: Schema = Schema.ofArray('schema')
+        .setItems(ast)
+        .setAdditionalItems(new AdditionalType().setBooleanValue(true));
+
+    let arr = [12, 'surendhar', { a: 'val1', b: 'val2' }, 1, 2, 4];
+
+    expect(ArrayValidator.validate([], schema, repo, arr)).toStrictEqual(arr);
+});
+
+test('schema array validator test for tuple with add schema', () => {
+    let tupleS: Schema[] = [
+        Schema.ofInteger('item1'),
+        Schema.ofString('item2'),
+        Schema.ofObject('item3'),
+    ];
+
+    let ast = new ArraySchemaType();
+    ast.setTupleSchema(tupleS);
+
+    const schema: Schema = Schema.ofArray('schema')
+        .setItems(ast)
+        .setAdditionalItems(new AdditionalType().setSchemaValue(Schema.ofInteger('itemInt')));
+
+    let arr = [12, 'surendhar', { a: 'val1', b: 'val2' }, 1, 2];
+
+    expect(ArrayValidator.validate([], schema, repo, arr)).toStrictEqual(arr);
+});
+
+test('schema array validator test for tuple with add schema fail', () => {
+    let tupleS: Schema[] = [
+        Schema.ofInteger('item1'),
+        Schema.ofString('item2'),
+        Schema.ofObject('item3'),
+    ];
+
+    let ast = new ArraySchemaType();
+    ast.setTupleSchema(tupleS);
+
+    const schema: Schema = Schema.ofArray('schema')
+        .setItems(ast)
+        .setAdditionalItems(new AdditionalType().setSchemaValue(Schema.ofInteger('itemInt')));
+
+    let arr = [12, 'surendhar', { a: 'val1', b: 'val2' }, 1, 2, 4, 'surendhar'];
+
+    expect(() => ArrayValidator.validate([], schema, repo, arr)).toThrow();
+});
+
+test('schema array validator test for tuple with add schema fail', () => {
+    let tupleS: Schema[] = [Schema.ofInteger('item1'), Schema.ofString('item2')];
+
+    let ast = new ArraySchemaType();
+    ast.setTupleSchema(tupleS);
+
+    const schema: Schema = Schema.ofArray('schema')
+        .setItems(ast)
+        .setAdditionalItems(new AdditionalType().setSchemaValue(Schema.ofInteger('itemInt')));
+
+    let arr = [12, 'surendhar', { a: 'val1', b: 'val2' }, 1, 2, 4, ['ve', 23, 'ctor']];
+
+    expect(() => ArrayValidator.validate([], schema, repo, arr)).toThrow();
+});
+
+test('schema array validator test for single with additional', () => {
+    let ast = new ArraySchemaType();
+    ast.setSingleSchema(Schema.ofInteger('ast'));
+
+    const schema: Schema = Schema.ofArray('schema')
+        .setItems(ast)
+        .setAdditionalItems(new AdditionalType().setBooleanValue(true));
+
+    let arr = [12, 23, 54, 45, 'abcd', 'df'];
+
+    expect(() => ArrayValidator.validate([], schema, repo, arr)).toThrow();
+});
+
+test('schema array validator test for tuple without additional', () => {
+    let tupleS: Schema[] = [
+        Schema.ofInteger('item1'),
+        Schema.ofString('item2'),
+        Schema.ofObject('item3'),
+    ];
+
+    let ast = new ArraySchemaType();
+    ast.setTupleSchema(tupleS);
+
+    const schema: Schema = Schema.ofArray('schema').setItems(ast);
+
+    let arr = [12, 'surendhar', { a: 'val1', b: 'val2' }, 'add'];
+
+    expect(() => ArrayValidator.validate([], schema, repo, arr)).toThrow();
+});
+
+test('schema array validator tuple schema with json object', () => {
+    let tupleS: Schema[] = [
+        Schema.ofInteger('item1'),
+        Schema.ofString('item2'),
+        Schema.ofObject('item3'),
+    ];
+
+    let ast = new ArraySchemaType();
+    ast.setTupleSchema(tupleS);
+
+    const schema: Schema = Schema.ofArray('schema').setItems(ast);
+
+    let obj = [1, 'asd', { val: 'stringtype' }, 'stringOnemore'];
+
+    expect(() => SchemaValidator.validate([], schema, repo, obj)).toThrowError();
+});
+
+test('schema array validator tuple schema similar to json object', () => {
+    let tupleS: Schema[] = [
+        Schema.ofInteger('item1'),
+        Schema.ofString('item2'),
+        Schema.ofBoolean('item3'),
+    ];
+
+    let ast = new ArraySchemaType();
+    ast.setTupleSchema(tupleS);
+
+    let objSc = Schema.ofObject('obj');
+
+    const schema: Schema = Schema.ofArray('schema')
+        .setItems(ast)
+        .setAdditionalItems(new AdditionalType().setSchemaValue(objSc));
+
+    let obj = [1, 'asd', true, { val: 'stringtype' }, false];
+
+    expect(() => SchemaValidator.validate([], schema, repo, obj)).toThrowError();
+});