Validate schema's default values (#2511)

* commented out

* completed isValidDefaultCoordinates and isValidSchema functions

* added console log test cases

* added a checker for type

* refactored to be drier

* added warning and fixed check to consider 0 as a coordinate

* removed change in index.html

* changed opacity default from a string of 1.0 to the number

* removed forward slashes from description and deleted new lines

* made param for isValidaDefaultCoordinate more descriptive

* removed accidental file commit

* changed name from validate.js to validate-schema.js

* adjusted the file path to correct file name

* added curly brackets to isValidDefaultValue, moved validation methods into schema, reversed conditional statement for validation warning

* null is valid default value for coordinates, refactored conditionals to be cleaner

* added unit tests for isValidDefaultCoordinate

* completed tests for isValidDefaultValue, almost modified isValidDefaultCoordinate tests to have a test for null

Author: dye784

src/components/text.js

@@ -61,7 +61,7 @@ module.exports.Component = registerComponent('text', {
     letterSpacing: {type: 'number', default: 0},
     // `lineHeight` defaults to font's `lineHeight` value.
     lineHeight: {type: 'number'},
-    opacity: {type: 'number', default: '1.0'},
+    opacity: {type: 'number', default: 1.0},
     shader: {default: 'sdf', oneOf: shaders},
     side: {default: 'front', oneOf: ['front', 'back', 'double']},
     tabSize: {default: 4},

src/core/schema.js

@@ -72,8 +72,14 @@ function processPropertyDefinition (propDefinition) {
   // Fill in type name.
   propDefinition.type = typeName;
 
-  // Fill in default value.
-  if (!('default' in propDefinition)) {
+  // Check if default value exists.
+  if ('default' in propDefinition) {
+    // Check if default values are valid
+    if (!isValidDefaultValue(typeName, defaultVal)) {
+      warn('The default value: ' + '"' + defaultVal + '"' + ' does not match the type: ' + typeName);
+    }
+  } else {
+    // Fill in default value.
     propDefinition.default = propType.default;
   }
 
@@ -160,3 +166,59 @@ function stringifyProperty (value, propDefinition) {
   return propDefinition.stringify(value);
 }
 module.exports.stringifyProperty = stringifyProperty;
+
+/**
+ * Checks if Valid default coordinates
+ * @param {unknown} possibleCoordinates
+ * @param {number} dimensions - 2 for 2D Vector or 3 for 3D vector
+ * @returns {boolean} A boolean determining if coordinates are parsed correctly.
+ */
+function isValidDefaultCoordinate (possibleCoordinates, dimensions) {
+  if (possibleCoordinates === null) { return true; }
+  if (typeof possibleCoordinates !== 'object') { return false; }
+
+  if (Object.keys(possibleCoordinates).length !== dimensions) {
+    return false;
+  } else {
+    var x = possibleCoordinates.x;
+    var y = possibleCoordinates.y;
+    var z = possibleCoordinates.z;
+    var w = possibleCoordinates.w;
+
+    if (typeof x !== 'number' || typeof y !== 'number') { return false; }
+    if (dimensions > 2 && typeof z !== 'number') { return false; }
+    if (dimensions > 3 && typeof w !== 'number') { return false; }
+  }
+
+  return true;
+}
+module.exports.isValidDefaultCoordinate = isValidDefaultCoordinate;
+
+/**
+ * Validates the default values in a schema
+ * @param {string} type - type in a prop
+ * @param {unknown} defaultVal - default in a prop
+ * @returns {boolean} A boolean determining if defaults are valid.
+ */
+function isValidDefaultValue (type, defaultVal) {
+  if (type === 'audio' && typeof defaultVal !== 'string') { return false; }
+  if (type === 'array' && !Array.isArray(defaultVal)) { return false; }
+  if (type === 'asset' && typeof defaultVal !== 'string') { return false; }
+  if (type === 'boolean' && typeof defaultVal !== 'boolean') { return false; }
+  if (type === 'color' && typeof defaultVal !== 'string') { return false; }
+  if (type === 'int' && typeof defaultVal !== 'number') { return false; }
+  if (type === 'number' && typeof defaultVal !== 'number') { return false; }
+  if (type === 'map' && typeof defaultVal !== 'string') { return false; }
+  if (type === 'model' && typeof defaultVal !== 'string') { return false; }
+  if (type === 'selector' && typeof defaultVal !== 'string') { return false; }
+  if (type === 'selectorAll' && typeof defaultVal !== 'string') { return false; }
+  if (type === 'src' && typeof defaultVal !== 'string') { return false; }
+  if (type === 'string' && typeof defaultVal !== 'string') { return false; }
+  if (type === 'time' && typeof defaultVal !== 'number') { return false; }
+  if (type === 'vec2') { return isValidDefaultCoordinate(defaultVal, 2); }
+  if (type === 'vec3') { return isValidDefaultCoordinate(defaultVal, 3); }
+  if (type === 'vec4') { return isValidDefaultCoordinate(defaultVal, 4); }
+
+  return true;
+}
+module.exports.isValidDefaultValue = isValidDefaultValue;

tests/core/schema.test.js

@@ -7,6 +7,8 @@ var parseProperties = Schema.parseProperties;
 var parseProperty = Schema.parseProperty;
 var processSchema = Schema.process;
 var stringifyProperty = Schema.stringifyProperty;
+var isValidDefaultCoordinate = Schema.isValidDefaultCoordinate;
+var isValidDefaultValue = Schema.isValidDefaultValue;
 
 suite('schema', function () {
   suite('isSingleProperty', function () {
@@ -205,4 +207,84 @@ suite('schema', function () {
       assert.equal(parsedValue, 'null');
     });
   });
+
+  suite('isValidDefaultCoordinate', function () {
+    test('is true for null', function () {
+      assert.equal(isValidDefaultCoordinate(null, 2), true);
+    });
+    test('is true for vec2 if { x: num, y:num }', function () {
+      var validCoordinates = { x: 1, y: 2 };
+      assert.equal(isValidDefaultCoordinate(validCoordinates, 2), true);
+    });
+
+    test('is true for vec3 if { x: num, y:num z: num }', function () {
+      var validCoordinates = { x: 1, y: 2, z: 3 };
+      assert.equal(isValidDefaultCoordinate(validCoordinates, 3), true);
+    });
+
+    test('is true for vec4 if { x: num, y:num z: num w: num }', function () {
+      var validCoordinates = { x: 1, y: 2, z: 3, w: 4 };
+      assert.equal(isValidDefaultCoordinate(validCoordinates, 4), true);
+    });
+
+    test('is false for everything else', function () {
+      var invalidCoordinates1 = { notX: 1 };
+      var invalidCoordinates2 = { x: '' };
+      var invalidCoordinates3 = { x: 0, z: 5 };
+      var invalidCoordinates4 = { x: 5, y: {} };
+      var invalidCoordinates5 = { x: 1, y: [] };
+      var invalidCoordinates6 = { notX: 'not coordinates at all' };
+      var invalidCoordinates7 = { x: 5, y: 1, z: 2 }; // Invalid for vec4
+      assert.equal(isValidDefaultCoordinate(invalidCoordinates1, 2), false);
+      assert.equal(isValidDefaultCoordinate(invalidCoordinates2, 2), false);
+      assert.equal(isValidDefaultCoordinate(invalidCoordinates3, 2), false);
+      assert.equal(isValidDefaultCoordinate(invalidCoordinates4, 3), false);
+      assert.equal(isValidDefaultCoordinate(invalidCoordinates5, 4), false);
+      assert.equal(isValidDefaultCoordinate(invalidCoordinates6, 4), false);
+      assert.equal(isValidDefaultCoordinate(invalidCoordinates7, 4), false);
+    });
+  });
+
+  suite('isValidDefaultValue', function () {
+    test('is true when type and typeof default value matches', function () {
+      assert.equal(isValidDefaultValue('audio', 'string'), true);
+      assert.equal(isValidDefaultValue('array', []), true);
+      assert.equal(isValidDefaultValue('asset', 'string'), true);
+      assert.equal(isValidDefaultValue('boolean', true), true);
+      assert.equal(isValidDefaultValue('color', '#FFF'), true);
+      assert.equal(isValidDefaultValue('int', 9000), true);
+      assert.equal(isValidDefaultValue('number', 42), true);
+      assert.equal(isValidDefaultValue('map', 'string'), true);
+      assert.equal(isValidDefaultValue('model', 'string'), true);
+      assert.equal(isValidDefaultValue('selector', 'string'), true);
+      assert.equal(isValidDefaultValue('selectorAll', 'string'), true);
+      assert.equal(isValidDefaultValue('src', 'string'), true);
+      assert.equal(isValidDefaultValue('string', 'string'), true);
+      assert.equal(isValidDefaultValue('time', 24), true);
+      assert.equal(isValidDefaultValue('vec2', { x: 1, y: 1 }), true);
+      assert.equal(isValidDefaultValue('vec3', { x: 0, y: 9, z: 0 }), true);
+      assert.equal(isValidDefaultValue('vec4', { x: 9, y: 9, z: 9, w: 9 }), true);
+      assert.equal(isValidDefaultValue('vec4', null), true);
+    });
+
+    test('is false for everything else', function () {
+      assert.equal(isValidDefaultValue('audio', 1), false);
+      assert.equal(isValidDefaultValue('array', {}), false);
+      assert.equal(isValidDefaultValue('asset', 2), false);
+      assert.equal(isValidDefaultValue('boolean', { not: 'a boolean' }), false);
+      assert.equal(isValidDefaultValue('color', 123456), false);
+      assert.equal(isValidDefaultValue('int', 'not a number'), false);
+      assert.equal(isValidDefaultValue('number', ['something else']), false);
+      assert.equal(isValidDefaultValue('map', 3), false);
+      assert.equal(isValidDefaultValue('model', 4), false);
+      assert.equal(isValidDefaultValue('selector', 5), false);
+      assert.equal(isValidDefaultValue('selectorAll', 6), false);
+      assert.equal(isValidDefaultValue('src', 7), false);
+      assert.equal(isValidDefaultValue('string', 8), false);
+      assert.equal(isValidDefaultValue('time', 'string'), false);
+      assert.equal(isValidDefaultValue('vec2', [1, 2, 3]), false);
+      assert.equal(isValidDefaultValue('vec3', undefined), false);
+      assert.equal(isValidDefaultValue('vec4', false), false);
+    });
+  });
 });