feat: adds check for case-insensitive property name collisions (#162)

Author: rmkeezer

README.md

@@ -265,6 +265,7 @@ The supported rules are described below:
 | array_of_arrays             | Flag any schema with a 'property' of type `array` with items of type `array`. | shared   |
 | inconsistent_property_type  | Flag any properties that have the same name but an inconsistent type.         | shared   |
 | property_case_convention    | Flag any property with a `name` that does not follow a given case convention. snake_case_only must be 'off' to use. | shared |
+| property_case_collision     | Flag any property with a `name` that is identical to another property's `name` except for the naming convention | shared |
 | enum_case_convention        | Flag any enum with a `value` that does not follow a given case convention. snake_case_only must be 'off' to use.    | shared |
 | json_or_param_binary_string | Flag parameters or application/json request/response bodies with schema type: string, format: binary. | oas3 |
 
@@ -445,6 +446,7 @@ The default values for each rule are described below.
 | array_of_arrays             | warning |
 | inconsistent_property_type  | warning |
 | property_case_convention    | error, lower_snake_case |
+| property_case_collision     | error   |
 | enum_case_convention        | error, lower_snake_case |
 
 ###### walker

src/.defaultsForValidator.js

@@ -66,6 +66,7 @@ const defaults = {
       'array_of_arrays': 'warning',
       'inconsistent_property_type': 'warning',
       'property_case_convention': [ 'error', 'lower_snake_case'],
+      'property_case_collision': 'error',
       'enum_case_convention': [ 'error', 'lower_snake_case']
     },
     'walker': {

src/plugins/validation/2and3/semantic-validators/schema-ibm.js

@@ -115,7 +115,7 @@ module.exports.validate = function({ jsSpec, isOAS3 }, config) {
 
       checkEnumValues(schema, path, config, messages);
     } else {
-      // optional support for property_case_convention and enum_case_convention
+      // optional support for property_case_convention, property_case_collision, and enum_case_convention
       // in config.  In the else block because support should be mutually exclusive
       // with config.snake_case_only since it is overlapping functionality
       if (config.property_case_convention) {
@@ -129,6 +129,17 @@ module.exports.validate = function({ jsSpec, isOAS3 }, config) {
           );
         }
       }
+      if (config.property_case_collision) {
+        const checkCaseStatus = config.property_case_collision;
+        if (checkCaseStatus !== 'off') {
+          checkPropNamesCaseCollision(
+            schema,
+            path,
+            config.property_case_collision,
+            messages
+          );
+        }
+      }
       if (config.enum_case_convention) {
         const checkCaseStatus = config.enum_case_convention[0];
         if (checkCaseStatus !== 'off') {
@@ -415,11 +426,50 @@ function checkPropNames(schema, contextPath, config, messages) {
   });
 }
 
+/**
+ * Check that property names follow the specified case convention
+ * @param schema
+ * @param contextPath
+ * @param checkStatus a string, 'off' | 'warning' | 'error'
+ * @param messages
+ */
+function checkPropNamesCaseCollision(
+  schema,
+  contextPath,
+  checkStatus,
+  messages
+) {
+  if (!schema.properties) {
+    return;
+  }
+
+  // flag any property whose name is identical to another property in a different case
+  const prevProps = [];
+  forIn(schema.properties, (property, propName) => {
+    if (propName.slice(0, 2) === 'x-') return;
+
+    // Skip case_convention checks for deprecated properties
+    if (propName.deprecated === true) return;
+
+    const caselessPropName = propName.replace(/[_-]/g, '').toLowerCase();
+    if (prevProps.includes(caselessPropName)) {
+      messages.addMessage(
+        contextPath.concat(['properties', propName]),
+        `Property name is identical to another property except for the naming convention: ${propName}`,
+        checkStatus
+      );
+    } else {
+      prevProps.push(caselessPropName);
+    }
+  });
+}
+
 /**
  * Check that property names follow the specified case convention
  * @param schema
  * @param contextPath
  * @param caseConvention an array, [0]='off' | 'warning' | 'error'. [1]='lower_snake_case' etc.
+ * @param messages
  */
 function checkPropNamesCaseConvention(
   schema,
@@ -481,6 +531,7 @@ function checkEnumValues(schema, contextPath, config, messages) {
  * @param schema
  * @param contextPath
  * @param caseConvention an array, [0]='off' | 'warning' | 'error'. [1]='lower_snake_case' etc.
+ * @param messages
  */
 function checkEnumCaseConvention(
   schema,

test/plugins/validation/2and3/schema-ibm.js

@@ -537,6 +537,48 @@ describe('validation plugin - semantic - schema-ibm - Swagger 2', () => {
     expect(res.warnings.length).toEqual(0);
   });
 
+  // tests for explicit name collisions
+  it('should return a warning when two property names of different case conventions are identical if converted to a single case', () => {
+    const customConfig = {
+      schemas: {
+        snake_case_only: 'off',
+        property_case_convention: 'warning'
+      }
+    };
+
+    const spec = {
+      definitions: {
+        Thing: {
+          type: 'object',
+          description: 'thing',
+          properties: {
+            thingString: {
+              type: 'string',
+              description: 'thing string'
+            },
+            thing_string: {
+              type: 'string',
+              description: 'thing string'
+            }
+          }
+        }
+      }
+    };
+
+    const res = validate({ jsSpec: spec }, customConfig);
+    expect(res.errors.length).toEqual(0);
+    expect(res.warnings.length).toEqual(1);
+    expect(res.warnings[0].path).toEqual([
+      'definitions',
+      'Thing',
+      'properties',
+      'thingString'
+    ]);
+    expect(res.warnings[0].message).toEqual(
+      'Property name is identical to another property except for the naming convention: thingString'
+    );
+  });
+
   it('should not return a case_convention error when property is deprecated', () => {
     const spec = {
       definitions: {