fix(ibm-integer-attributes): add validation for type integer ranges

packages/ruleset/src/functions/integer-attributes.js

@@ -29,6 +29,13 @@ module.exports = function (schema, _opts, context) {
 // These are the valid format values that can be used with integer schemas.
 const intFormats = ['int32', 'int64'];
 
+//These are the minimum and maximum values for integer schemas
+const int32Minimum = -2147483648;
+const int32Maximum = 2147483647;
+
+const int64Minimum = -9007199254740991;
+const int64Maximum = 9007199254740991;
+
 /**
  * This function performs various checks on an integer schema property to make sure it
  * contains the "minimum", "maximum" attributes.
@@ -70,11 +77,40 @@ function integerBoundaryErrors(schema, path) {
         path,
       });
     }
-    if (isDefined(minimum) && isDefined(maximum) && minimum > maximum) {
-      errors.push({
-        message: `'minimum' cannot be greater than 'maximum'`,
-        path,
-      });
+    if (isDefined(minimum) && isDefined(maximum)) {
+      if (minimum > maximum) {
+        errors.push({
+          message: `'minimum' cannot be greater than 'maximum'`,
+          path,
+        });
+      }
+      if (format === 'int32') {
+        if (minimum > int32Maximum || minimum < int32Minimum) {
+          errors.push({
+            message: `'minimum' value is out of safe range`,
+            path,
+          });
+        }
+        if (maximum > int32Maximum || maximum < int32Minimum) {
+          errors.push({
+            message: `'maximum' value is out of safe range`,
+            path,
+          });
+        }
+      } else {
+        if (minimum > int64Maximum || minimum < int64Minimum) {
+          errors.push({
+            message: `'minimum' value is out of safe range`,
+            path,
+          });
+        }
+        if (maximum > int64Maximum || maximum < int64Minimum) {
+          errors.push({
+            message: `'maximum' value is out of safe range`,
+            path,
+          });
+        }
+      }
     }
 
     return errors;

packages/ruleset/test/rules/integer-attributes.test.js

@@ -464,5 +464,69 @@ describe(`Spectral rule: ${ruleId}`, () => {
         expect(results[i].path.join('.')).toBe(expectedPaths[i]);
       }
     });
+    it('Integer schema int32 minimum is out of safe range', async () => {
+      const testDocument = makeCopy(rootDocument);
+      testDocument.paths['/v1/movies'].post.parameters = [
+        {
+          name: 'max_movie_length',
+          in: 'query',
+          schema: {
+            type: 'integer',
+            format: 'int32',
+            minimum: -9007199254740991,
+            maximum: 2147483649,
+          },
+        },
+      ];
+
+      const results = await testRule(ruleId, rule, testDocument);
+      expect(results).toHaveLength(2);
+
+      const expectedPath = 'paths./v1/movies.post.parameters.0.schema';
+
+      const expectedMessages = [
+        `'minimum' value is out of safe range`,
+        `'maximum' value is out of safe range`,
+      ];
+
+      for (let i = 0; i < results.length; i++) {
+        expect(results[i].code).toBe(ruleId);
+        expect(results[i].message).toBe(expectedMessages[i]);
+        expect(results[i].severity).toBe(expectedSeverity);
+        expect(results[i].path.join('.')).toBe(expectedPath);
+      }
+    });
+    it('Integer schema int64 minimum is out of safe range', async () => {
+      const testDocument = makeCopy(rootDocument);
+      testDocument.paths['/v1/movies'].post.parameters = [
+        {
+          name: 'max_movie_length',
+          in: 'query',
+          schema: {
+            type: 'integer',
+            format: 'int64',
+            minimum: -9007199254740992,
+            maximum: -9007199254740992,
+          },
+        },
+      ];
+
+      const results = await testRule(ruleId, rule, testDocument);
+      expect(results).toHaveLength(2);
+
+      const expectedPath = 'paths./v1/movies.post.parameters.0.schema';
+
+      const expectedMessages = [
+        `'minimum' value is out of safe range`,
+        `'maximum' value is out of safe range`,
+      ];
+
+      for (let i = 0; i < results.length; i++) {
+        expect(results[i].code).toBe(ruleId);
+        expect(results[i].message).toBe(expectedMessages[i]);
+        expect(results[i].severity).toBe(expectedSeverity);
+        expect(results[i].path.join('.')).toBe(expectedPath);
+      }
+    });
   });
 });