@jsonforms/core 3.0.0-beta.1 → 3.0.0-beta.4

package/test/testers.test.ts

@@ -45,7 +45,8 @@ import {
   schemaTypeIs,
   scopeEndIs,
   scopeEndsWith,
-  uiTypeIs
+  uiTypeIs,
+  isOneOfEnumControl
 } from '../src/testers';
 import {
   ControlElement,
@@ -74,8 +75,8 @@ test('schemaTypeIs should check type sub-schema of control', t => {
     type: 'Control',
     scope: '#/properties/foo'
   };
-  t.true(schemaTypeIs('string')(uischema, schema));
-  t.false(schemaTypeIs('integer')(uischema, schema));
+  t.true(schemaTypeIs('string')(uischema, schema, schema));
+  t.false(schemaTypeIs('integer')(uischema, schema, schema));
 });
 
 test('schemaTypeIs should return false for non-control UI schema elements', t => {
@@ -89,7 +90,7 @@ test('schemaTypeIs should return false for non-control UI schema elements', t =>
     type: 'Label',
     text: 'some text'
   };
-  t.false(schemaTypeIs('integer')(label, schema));
+  t.false(schemaTypeIs('integer')(label, schema, schema));
 });
 
 test('schemaTypeIs should return false for control pointing to invalid sub-schema', t => {
@@ -103,7 +104,7 @@ test('schemaTypeIs should return false for control pointing to invalid sub-schem
       foo: { type: 'string' }
     }
   };
-  t.false(schemaTypeIs('string')(uischema, schema));
+  t.false(schemaTypeIs('string')(uischema, schema, schema));
 });
 
 test('schemaTypeIs should return true for array type', t => {
@@ -117,8 +118,8 @@ test('schemaTypeIs should return true for array type', t => {
     type: 'Control',
     scope: '#/properties/foo'
   };
-  t.true(schemaTypeIs('string')(uischema, schema));
-  t.true(schemaTypeIs('integer')(uischema, schema));
+  t.true(schemaTypeIs('string')(uischema, schema, schema));
+  t.true(schemaTypeIs('integer')(uischema, schema, schema));
 });
 
 test('formatIs should check the format of a resolved sub-schema', t => {
@@ -135,7 +136,7 @@ test('formatIs should check the format of a resolved sub-schema', t => {
       }
     }
   };
-  t.true(formatIs('date-time')(uischema, schema));
+  t.true(formatIs('date-time')(uischema, schema, schema));
 });
 
 test('uiTypeIs', t => {
@@ -143,7 +144,7 @@ test('uiTypeIs', t => {
     type: 'Control',
     scope: '#/properties/bar'
   };
-  t.true(uiTypeIs('Control')(control, undefined));
+  t.true(uiTypeIs('Control')(control, undefined, undefined));
 });
 
 test('optionIs should check for options', t => {
@@ -154,13 +155,13 @@ test('optionIs should check for options', t => {
       answer: 42
     }
   };
-  t.true(optionIs('answer', 42)(control, undefined));
+  t.true(optionIs('answer', 42)(control, undefined, undefined));
 });
 
 test('optionIs should not fail if uischema is undefined or null', t => {
   const uischema: UISchemaElement = null;
-  t.false(optionIs('answer', 42)(uischema, undefined));
-  t.false(optionIs('answer', 42)(uischema, undefined));
+  t.false(optionIs('answer', 42)(uischema, undefined, undefined));
+  t.false(optionIs('answer', 42)(uischema, undefined, undefined));
 });
 
 test('optionIs should return false for UI schema elements without options cell', t => {
@@ -168,7 +169,7 @@ test('optionIs should return false for UI schema elements without options cell',
     type: 'Control',
     scope: '#/properties/bar'
   };
-  t.false(optionIs('answer', 42)(control, undefined));
+  t.false(optionIs('answer', 42)(control, undefined, undefined));
 });
 
 test('schemaMatches should check type sub-schema of control via predicate', t => {
@@ -183,7 +184,7 @@ test('schemaMatches should check type sub-schema of control via predicate', t =>
     scope: '#/properties/foo'
   };
   t.true(
-    schemaMatches(subSchema => subSchema.type === 'string')(uischema, schema)
+    schemaMatches(subSchema => subSchema.type === 'string')(uischema, schema, schema)
   );
 });
 
@@ -198,7 +199,7 @@ test('schemaMatches should check type sub-schema of control via predicate also w
     scope: '#/properties/foo'
   };
   t.true(
-    schemaMatches(subSchema => subSchema.type === 'string')(uischema, schema)
+    schemaMatches(subSchema => subSchema.type === 'string')(uischema, schema, schema)
   );
 });
 
@@ -213,7 +214,7 @@ test('schemaMatches should return false for non-control UI schema elements', t =
     type: 'Label',
     text: 'some text'
   };
-  t.false(schemaMatches(() => false)(label, schema));
+  t.false(schemaMatches(() => false)(label, schema, schema));
 });
 
 test('schemaMatches should return false for control pointing to invalid subschema', t => {
@@ -227,7 +228,7 @@ test('schemaMatches should return false for control pointing to invalid subschem
     type: 'Control',
     scope: '#/properties/bar'
   };
-  t.false(schemaMatches(() => false)(uischema, schema));
+  t.false(schemaMatches(() => false)(uischema, schema, schema));
 });
 
 test('scopeEndsWith checks whether the ref of a control ends with a certain string', t => {
@@ -235,7 +236,7 @@ test('scopeEndsWith checks whether the ref of a control ends with a certain stri
     type: 'Control',
     scope: '#/properties/bar'
   };
-  t.true(scopeEndsWith('properties/bar')(uischema, undefined));
+  t.true(scopeEndsWith('properties/bar')(uischema, undefined, undefined));
 });
 
 test('scopeEndsWith should return false for non-control UI schema elements', t => {
@@ -243,7 +244,7 @@ test('scopeEndsWith should return false for non-control UI schema elements', t =
     type: 'Label',
     text: 'some text'
   };
-  t.false(scopeEndsWith('properties/bar')(label, undefined));
+  t.false(scopeEndsWith('properties/bar')(label, undefined, undefined));
 });
 
 test('refEndIs checks whether the last segment a control ref equals a certain string', t => {
@@ -251,7 +252,7 @@ test('refEndIs checks whether the last segment a control ref equals a certain st
     type: 'Control',
     scope: '#/properties/bar'
   };
-  t.true(scopeEndIs('bar')(uischema, undefined));
+  t.true(scopeEndIs('bar')(uischema, undefined, undefined));
 });
 
 test('refEndIs should return false for non-control UI schema elements', t => {
@@ -259,7 +260,7 @@ test('refEndIs should return false for non-control UI schema elements', t => {
     type: 'Label',
     text: 'some text'
   };
-  t.false(scopeEndIs('bar')(label, undefined));
+  t.false(scopeEndIs('bar')(label, undefined, undefined));
 });
 
 test('and should allow to compose multiple testers', t => {
@@ -273,7 +274,7 @@ test('and should allow to compose multiple testers', t => {
     type: 'Control',
     scope: '#/properties/foo'
   };
-  t.true(and(schemaTypeIs('string'), scopeEndIs('foo'))(uischema, schema));
+  t.true(and(schemaTypeIs('string'), scopeEndIs('foo'))(uischema, schema, schema));
 });
 
 test('or should allow to compose multiple testers', t => {
@@ -288,7 +289,7 @@ test('or should allow to compose multiple testers', t => {
     scope: '#/properties/foo'
   };
   t.true(
-    or(schemaTypeIs('integer'), optionIs('slider', true))(uischema, schema)
+    or(schemaTypeIs('integer'), optionIs('slider', true))(uischema, schema, schema)
   );
 });
 
@@ -297,52 +298,68 @@ test('tester isPrimitiveArrayControl', t => {
     type: 'Control',
     scope: '#/properties/foo'
   };
-  t.true(
-    isPrimitiveArrayControl(control, {
-      type: 'object',
-      properties: {
-        foo: {
-          type: 'array',
-          items: { type: 'integer' }
-        }
+  const schema = {
+    type: 'object',
+    properties: {
+      foo: {
+        type: 'array',
+        items: { type: 'integer' }
       }
-    }),
+    }
+  };
+  t.true(
+    isPrimitiveArrayControl(control, schema, schema),
     `Primitive array tester was not triggered for 'integer' schema type`
   );
-  t.false(
-    isPrimitiveArrayControl(control, {
-      type: 'object',
-      properties: {
-        foo: {
-          type: 'array',
-          items: { type: 'object' }
-        }
+  const schemaWithRefs = {
+    definitions: { int: { type: 'integer' } },
+    type: 'object',
+    properties: {
+      foo: {
+        type: 'array',
+        items: { $ref: '#/definitions/int' }
       }
-    }),
+    }
+  };
+  t.true(
+    isPrimitiveArrayControl(control, schemaWithRefs, schemaWithRefs),
+    `Primitive array tester was not triggered for 'integer' schema type with refs`
+  );
+  const objectSchema = {
+    type: 'object',
+    properties: {
+      foo: {
+        type: 'array',
+        items: { type: 'object' }
+      }
+    }
+  };
+  t.false(
+    isPrimitiveArrayControl(control, objectSchema, objectSchema),
     `Primitive array tester was not triggered for 'object' schema type`
   );
 });
 
 test('tester isObjectArrayControl', t => {
-  t.false(isObjectArrayControl({ type: 'Foo' }, null));
+  t.false(isObjectArrayControl({ type: 'Foo' }, null, null));
   const control: ControlElement = {
     type: 'Control',
     scope: '#/properties/foo'
   };
-  t.false(isObjectArrayControl(control, undefined), 'No Schema not checked!');
+  t.false(isObjectArrayControl(control, undefined, undefined), 'No Schema not checked!');
 
   t.false(
     isObjectArrayControl(control, {
       type: 'object',
       properties: { bar: { type: 'integer' } }
-    }),
+    }, undefined),
     'Wrong Schema Type not checked!'
   );
   t.false(
     isObjectArrayControl(control, {
       type: 'object',
       properties: { foo: { type: 'array' } }
-    }),
+    }, undefined),
     'Array Schema Type without items not checked!'
   );
   t.false(
@@ -354,7 +371,7 @@ test('tester isObjectArrayControl', t => {
           items: [{ type: 'integer' }, { type: 'string' }]
         }
       }
-    }),
+    }, undefined),
     'Array Schema Type with tuples not checked!'
   );
   t.false(
@@ -366,7 +383,7 @@ test('tester isObjectArrayControl', t => {
           items: { type: 'integer' }
         }
       }
-    }),
+    }, undefined),
     'Array Schema Type with wrong item type not checked!'
   );
   const schema: JsonSchema = {
@@ -384,7 +401,7 @@ test('tester isObjectArrayControl', t => {
       }
     }
   };
-  t.true(isObjectArrayControl(control, schema));
+  t.true(isObjectArrayControl(control, schema, schema));
   const schema_noType: JsonSchema = {
     type: 'object',
     properties: {
@@ -399,7 +416,7 @@ test('tester isObjectArrayControl', t => {
       }
     }
   };
-  t.true(isObjectArrayControl(control, schema_noType));
+  t.true(isObjectArrayControl(control, schema_noType, schema_noType));
   const schema_innerAllOf: JsonSchema = {
     type: 'object',
     properties: {
@@ -422,44 +439,66 @@ test('tester isObjectArrayControl', t => {
       }
     }
   };
-  t.true(isObjectArrayControl(control, schema_innerAllOf));
+  t.true(isObjectArrayControl(control, schema_innerAllOf, schema_innerAllOf));
+
+  const schemaWithRefs = {
+    definitions: {
+      order: {
+        type: 'object',
+        properties: {
+          x: { type: 'integer' },
+          y: { type: 'integer' }
+        }
+      }
+    },
+    type: 'object',
+    properties: {
+      foo: {
+        type: 'array',
+        items: {
+          $ref: '#/definitions/order'
+        }
+      }
+    }
+  }
+  t.true(isObjectArrayControl(control, schemaWithRefs, schemaWithRefs));
 });
 
 test('isBooleanControl', t => {
-  t.false(isBooleanControl(undefined, undefined));
-  t.false(isBooleanControl(null, undefined));
-  t.false(isBooleanControl({ type: 'Foo' }, undefined));
-  t.false(isBooleanControl({ type: 'Control' }, undefined));
+  t.false(isBooleanControl(undefined, undefined, undefined));
+  t.false(isBooleanControl(null, undefined, undefined));
+  t.false(isBooleanControl({ type: 'Foo' }, undefined, undefined));
+  t.false(isBooleanControl({ type: 'Control' }, undefined, undefined));
   t.false(
     isBooleanControl(t.context.uischema, {
       type: 'object',
       properties: { foo: { type: 'string' } }
-    })
+    }, undefined)
   );
   t.false(
     isBooleanControl(t.context.uischema, {
       type: 'object',
       properties: { foo: { type: 'string' }, bar: { type: 'boolean' } }
-    })
+    }, undefined)
   );
   t.true(
     isBooleanControl(t.context.uischema, {
       type: 'object',
       properties: { foo: { type: 'boolean' } }
-    })
+    }, undefined)
   );
 });
 
 test('test isDateControl', t => {
-  t.false(isDateControl(undefined, undefined));
-  t.false(isDateControl(null, undefined));
-  t.false(isDateControl({ type: 'Foo' }, undefined));
-  t.false(isDateControl({ type: 'Control' }, undefined));
+  t.false(isDateControl(undefined, undefined, undefined));
+  t.false(isDateControl(null, undefined, undefined));
+  t.false(isDateControl({ type: 'Foo' }, undefined, undefined));
+  t.false(isDateControl({ type: 'Control' }, undefined, undefined));
   t.false(
     isDateControl(t.context.uischema, {
       type: 'object',
       properties: { foo: { type: 'string' } }
-    })
+    }, undefined)
   );
   t.false(
     isDateControl(t.context.uischema, {
@@ -471,25 +510,25 @@ test('test isDateControl', t => {
           format: 'date'
         }
       }
-    })
+    }, undefined)
   );
   t.true(
     isDateControl(t.context.uischema, {
       type: 'object',
       properties: { foo: { type: 'string', format: 'date' } }
-    })
+    }, undefined)
   );
 });
 test('test isEnumControl', t => {
-  t.false(isEnumControl(undefined, undefined));
-  t.false(isEnumControl(null, undefined));
-  t.false(isEnumControl({ type: 'Foo' }, undefined));
-  t.false(isEnumControl({ type: 'Control' }, undefined));
+  t.false(isEnumControl(undefined, undefined, undefined));
+  t.false(isEnumControl(null, undefined, undefined));
+  t.false(isEnumControl({ type: 'Foo' }, undefined, undefined));
+  t.false(isEnumControl({ type: 'Control' }, undefined, undefined));
   t.false(
     isEnumControl(t.context.uischema, {
       type: 'object',
       properties: { foo: { type: 'string' } }
-    })
+    }, undefined)
   );
   t.false(
     isEnumControl(t.context.uischema, {
@@ -503,109 +542,109 @@ test('test isEnumControl', t => {
           enum: ['a', 'b']
         }
       }
-    })
+    }, undefined)
   );
   t.true(
     isEnumControl(t.context.uischema, {
       type: 'object',
       properties: { foo: { type: 'string', enum: ['a', 'b'] } }
-    })
+    }, undefined)
   );
   t.true(
     isEnumControl(t.context.uischema, {
       type: 'object',
       properties: { foo: { type: 'number', enum: [1, 2] } }
-    })
+    }, undefined)
   );
   t.true(
     isEnumControl(t.context.uischema, {
       type: 'object',
       properties: { foo: { const: '1.0' } }
-    })
+    }, undefined)
   );
 });
 test('test isIntegerControl', t => {
-  t.false(isIntegerControl(undefined, undefined));
-  t.false(isIntegerControl(null, undefined));
-  t.false(isIntegerControl({ type: 'Foo' }, undefined));
-  t.false(isIntegerControl({ type: 'Control' }, undefined));
+  t.false(isIntegerControl(undefined, undefined, undefined));
+  t.false(isIntegerControl(null, undefined, undefined));
+  t.false(isIntegerControl({ type: 'Foo' }, undefined, undefined));
+  t.false(isIntegerControl({ type: 'Control' }, undefined, undefined));
   t.false(
     isIntegerControl(t.context.uischema, {
       type: 'object',
       properties: { foo: { type: 'string' } }
-    })
+    }, undefined)
   );
   t.false(
     isIntegerControl(t.context.uischema, {
       type: 'object',
       properties: { foo: { type: 'string' }, bar: { type: 'integer' } }
-    })
+    }, undefined)
   );
   t.true(
     isIntegerControl(t.context.uischema, {
       type: 'object',
       properties: { foo: { type: 'integer' } }
-    })
+    }, undefined)
   );
 });
 test('test isNumberControl', t => {
-  t.false(isNumberControl(undefined, undefined));
-  t.false(isNumberControl(null, undefined));
-  t.false(isNumberControl({ type: 'Foo' }, undefined));
-  t.false(isNumberControl({ type: 'Control' }, undefined));
+  t.false(isNumberControl(undefined, undefined, undefined));
+  t.false(isNumberControl(null, undefined, undefined));
+  t.false(isNumberControl({ type: 'Foo' }, undefined, undefined));
+  t.false(isNumberControl({ type: 'Control' }, undefined, undefined));
   t.false(
     isNumberControl(t.context.uischema, {
       type: 'object',
       properties: { foo: { type: 'string' } }
-    })
+    }, undefined)
   );
   t.false(
     isNumberControl(t.context.uischema, {
       type: 'object',
       properties: { foo: { type: 'string' }, bar: { type: 'number' } }
-    })
+    }, undefined)
   );
   t.true(
     isNumberControl(t.context.uischema, {
       type: 'object',
       properties: { foo: { type: 'number' } }
-    })
+    }, undefined)
   );
 });
 test('tester isStringControl', t => {
-  t.false(isStringControl(undefined, undefined));
-  t.false(isStringControl(null, undefined));
-  t.false(isStringControl({ type: 'Foo' }, undefined));
-  t.false(isStringControl({ type: 'Control' }, undefined));
+  t.false(isStringControl(undefined, undefined, undefined));
+  t.false(isStringControl(null, undefined, undefined));
+  t.false(isStringControl({ type: 'Foo' }, undefined, undefined));
+  t.false(isStringControl({ type: 'Control' }, undefined, undefined));
   t.false(
     isStringControl(t.context.uischema, {
       type: 'object',
       properties: { foo: { type: 'number' } }
-    })
+    }, undefined)
   );
   t.false(
     isStringControl(t.context.uischema, {
       type: 'object',
       properties: { foo: { type: 'number' }, bar: { type: 'string' } }
-    })
+    }, undefined)
   );
   t.true(
     isStringControl(t.context.uischema, {
       type: 'object',
       properties: { foo: { type: 'string' } }
-    })
+    }, undefined)
   );
 });
 test('test isTimeControl', t => {
-  t.false(isTimeControl(undefined, undefined));
-  t.false(isTimeControl(null, undefined));
-  t.false(isTimeControl({ type: 'Foo' }, undefined));
-  t.false(isTimeControl({ type: 'Control' }, undefined));
+  t.false(isTimeControl(undefined, undefined, undefined));
+  t.false(isTimeControl(null, undefined, undefined));
+  t.false(isTimeControl({ type: 'Foo' }, undefined, undefined));
+  t.false(isTimeControl({ type: 'Control' }, undefined, undefined));
   t.false(
     isTimeControl(t.context.uischema, {
       type: 'object',
       properties: { foo: { type: 'string' } }
-    })
+    }, undefined)
   );
   t.false(
     isTimeControl(t.context.uischema, {
@@ -614,25 +653,25 @@ test('test isTimeControl', t => {
         foo: { type: 'string' },
         bar: { type: 'string', format: 'time' }
       }
-    })
+    }, undefined)
   );
   t.true(
     isTimeControl(t.context.uischema, {
       type: 'object',
       properties: { foo: { type: 'string', format: 'time' } }
-    })
+    }, undefined)
   );
 });
 test('tester isMultiLineControl', t => {
-  t.false(isMultiLineControl(undefined, undefined));
-  t.false(isMultiLineControl(null, undefined));
-  t.false(isMultiLineControl({ type: 'Foo' }, undefined));
-  t.false(isMultiLineControl({ type: 'Control' }, undefined));
+  t.false(isMultiLineControl(undefined, undefined, undefined));
+  t.false(isMultiLineControl(null, undefined, undefined));
+  t.false(isMultiLineControl({ type: 'Foo' }, undefined, undefined));
+  t.false(isMultiLineControl({ type: 'Control' }, undefined, undefined));
   t.false(
     isMultiLineControl(t.context.uischema, {
       type: 'object',
       properties: { foo: { type: 'string' } }
-    })
+    }, undefined)
   );
   const control = t.context.uischema;
   control.options = { multi: true };
@@ -640,7 +679,7 @@ test('tester isMultiLineControl', t => {
     isMultiLineControl(control, {
       type: 'object',
       properties: { foo: { type: 'string' } }
-    })
+    }, undefined)
   );
 });
 
@@ -709,6 +748,15 @@ test('tester isObjectArrayWithNesting', t => {
     }
   };
 
+  const nestedSchemaWithRef =
+  {
+    definitions: { itemsType: { ...schema } },
+    type: 'array',
+    items: {
+      $ref: '#/definitions/itemsType'
+    }
+  };
+
   const uischemaOptions: {
     generate: ControlElement;
     default: ControlElement;
@@ -745,18 +793,19 @@ test('tester isObjectArrayWithNesting', t => {
     }
   };
 
-  t.false(isObjectArrayWithNesting(undefined, undefined));
-  t.false(isObjectArrayWithNesting(null, undefined));
-  t.false(isObjectArrayWithNesting({ type: 'Foo' }, undefined));
-  t.false(isObjectArrayWithNesting({ type: 'Control' }, undefined));
-  t.false(isObjectArrayWithNesting(uischema, schema));
-  t.true(isObjectArrayWithNesting(uischema, nestedSchema));
-  t.true(isObjectArrayWithNesting(uischema, nestedSchema2));
-  t.true(isObjectArrayWithNesting(uischema, nestedSchema3));
+  t.false(isObjectArrayWithNesting(undefined, undefined, undefined));
+  t.false(isObjectArrayWithNesting(null, undefined, undefined));
+  t.false(isObjectArrayWithNesting({ type: 'Foo' }, undefined, undefined));
+  t.false(isObjectArrayWithNesting({ type: 'Control' }, undefined, undefined));
+  t.false(isObjectArrayWithNesting(uischema, schema, undefined));
+  t.true(isObjectArrayWithNesting(uischema, nestedSchema, undefined));
+  t.true(isObjectArrayWithNesting(uischema, nestedSchema2, undefined));
+  t.true(isObjectArrayWithNesting(uischema, nestedSchema3, undefined));
+  t.true(isObjectArrayWithNesting(uischema, nestedSchemaWithRef, nestedSchemaWithRef));
 
-  t.false(isObjectArrayWithNesting(uischemaOptions.default, schema));
-  t.true(isObjectArrayWithNesting(uischemaOptions.generate, schema));
-  t.true(isObjectArrayWithNesting(uischemaOptions.inline, schema));
+  t.false(isObjectArrayWithNesting(uischemaOptions.default, schema, undefined));
+  t.true(isObjectArrayWithNesting(uischemaOptions.generate, schema, undefined));
+  t.true(isObjectArrayWithNesting(uischemaOptions.inline, schema, undefined));
 });
 
 test('tester schemaSubPathMatches', t => {
@@ -771,10 +820,12 @@ test('tester schemaSubPathMatches', t => {
     type: 'Control',
     scope: '#'
   };
+
   t.true(
     schemaSubPathMatches('items', items => items.type === 'number')(
       uischema,
-      schema
+      schema,
+      undefined
     )
   );
 });
@@ -783,6 +834,43 @@ test('tester not', t => {
   t.false(
     not(isBooleanControl)(t.context.uischema, {
       type: 'boolean'
-    })
+    }, undefined)
   );
 });
+
+test('tester isOneOfEnumControl', t => {
+  const control: ControlElement = {
+    type: 'Control',
+    scope: '#/properties/country'
+  };
+  const oneOfSchema = {
+    type: 'string',
+    oneOf: [
+      {
+        const: 'AU',
+        title: 'Australia'
+      },
+      {
+        const: 'NZ',
+        title: 'New Zealand'
+      }
+    ]
+  };
+
+  t.true(isOneOfEnumControl(control, {
+    type: 'object',
+    properties: {
+      country: oneOfSchema
+    }
+  }, undefined));
+  const schemaWithRefs = {
+    definitions: { country: oneOfSchema },
+    type: 'object',
+    properties: {
+      country: {
+        $ref: '#/definitions/country'
+      }
+    }
+  }
+  t.true(isOneOfEnumControl(control, schemaWithRefs, schemaWithRefs));
+});