@redocly/openapi-core 1.0.0 → 1.0.2

package/src/rules/__tests__/no-unresolved-refs.test.ts

@@ -0,0 +1,257 @@
+import path = require('path');
+import { outdent } from 'outdent';
+import { lintDocument } from '../../lint';
+import { BaseResolver } from '../../resolve';
+import { parseYamlToDocument, replaceSourceWithRef, makeConfig } from '../../../__tests__/utils';
+
+describe('oas3 boolean-parameter-prefixes', () => {
+  it('should report on unresolved $ref', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+        openapi: 3.0.0
+        paths:
+          '/test':
+            put:
+              requestBody:
+                $ref: 'invalid.yaml'
+      `,
+      path.join(__dirname, 'foobar.yaml')
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({
+        'no-unresolved-refs': 'error',
+      }),
+    });
+
+    expect(replaceSourceWithRef(results, __dirname)).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/paths/~1test/put/requestBody",
+              "reportOnKey": false,
+              "source": "foobar.yaml",
+            },
+          ],
+          "message": "Can't resolve $ref: ENOENT: no such file or directory 'invalid.yaml'",
+          "ruleId": "no-unresolved-refs",
+          "severity": "error",
+          "suggest": Array [],
+        },
+      ]
+    `);
+  });
+
+  it('should report on unresolved $ref yaml error', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+        openapi: 3.0.0
+        paths:
+          '/test':
+            put:
+              requestBody:
+                $ref: 'fixtures/invalid-yaml.yaml'
+      `,
+      path.join(__dirname, 'foobar.yaml')
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({
+        'no-unresolved-refs': 'error',
+      }),
+    });
+
+    expect(replaceSourceWithRef(results, __dirname)).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "location": Array [
+            Object {
+              "pointer": undefined,
+              "reportOnKey": false,
+              "source": "fixtures/invalid-yaml.yaml",
+              "start": Object {
+                "col": 1,
+                "line": 2,
+              },
+            },
+          ],
+          "message": "Failed to parse: unexpected end of the stream within a single quoted scalar in \\"fixtures/invalid-yaml.yaml\\" (2:1)",
+          "ruleId": "no-unresolved-refs",
+          "severity": "error",
+          "suggest": Array [],
+        },
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/paths/~1test/put/requestBody",
+              "reportOnKey": false,
+              "source": "foobar.yaml",
+            },
+          ],
+          "message": "Can't resolve $ref: unexpected end of the stream within a single quoted scalar in \\"fixtures/invalid-yaml.yaml\\" (2:1)",
+          "ruleId": "no-unresolved-refs",
+          "severity": "error",
+          "suggest": Array [],
+        },
+      ]
+    `);
+  });
+
+  it('should report on unresolved $ref yaml error', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+        openapi: 3.0.0
+        paths:
+          '/test':
+            put:
+              requestBody:
+                $ref: 'fixtures/ref.yaml'
+      `,
+      path.join(__dirname, 'foobar.yaml')
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({
+        'no-unresolved-refs': 'error',
+      }),
+    });
+
+    expect(replaceSourceWithRef(results, __dirname)).toMatchInlineSnapshot(`Array []`);
+  });
+
+  it('should report on unresolved localr ref', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+        openapi: 3.0.0
+        paths:
+          '/test':
+            put:
+              requestBody:
+                $ref: '#/components/requestBodies/a'
+      `,
+      path.join(__dirname, 'foobar.yaml')
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({
+        'no-unresolved-refs': 'error',
+      }),
+    });
+
+    expect(replaceSourceWithRef(results, __dirname)).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/paths/~1test/put/requestBody",
+              "reportOnKey": false,
+              "source": "foobar.yaml",
+            },
+          ],
+          "message": "Can't resolve $ref",
+          "ruleId": "no-unresolved-refs",
+          "severity": "error",
+          "suggest": Array [],
+        },
+      ]
+    `);
+  });
+
+  it('should not report on refs inside specification extensions', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+        openapi: 3.0.0
+        components:
+          requestBodies:
+            a:
+              content:
+                application/json:
+                  schema:
+                    type: object
+        x-webhooks:
+          test:
+            put:
+              requestBody:
+                $ref: '#/components/requestBodies/a'
+      `,
+      path.join(__dirname, 'foobar.yaml')
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({
+        'no-unresolved-refs': 'error',
+      }),
+    });
+
+    expect(replaceSourceWithRef(results, __dirname)).toMatchInlineSnapshot(`Array []`);
+  });
+
+  it('should not report on nested refs inside specification extensions', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+        openapi: 3.0.0
+        x-test:
+          prop:
+            $ref: 'fixtures/ref.yaml'
+        paths:
+          '/test':
+            get:
+              x-codeSamples:
+                - lang: PHP
+                  source:
+                    $ref: 'fixtures/code-sample.php'
+      `,
+      path.join(__dirname, 'foobar.yaml')
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({
+        'no-unresolved-refs': 'error',
+      }),
+    });
+
+    expect(replaceSourceWithRef(results, __dirname)).toMatchInlineSnapshot(`Array []`);
+  });
+
+  it('should not report on nested refs inside specification extensions for 3.1', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+        openapi: 3.1.0
+        x-test:
+          prop:
+            $ref: 'fixtures/ref.yaml'
+        paths:
+          '/test':
+            get:
+              x-codeSamples:
+                - lang: PHP
+                  source:
+                    $ref: 'fixtures/code-sample.php'
+      `,
+      path.join(__dirname, 'foobar.yaml')
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({
+        'no-unresolved-refs': 'error',
+      }),
+    });
+
+    expect(replaceSourceWithRef(results, __dirname)).toMatchInlineSnapshot(`Array []`);
+  });
+});

package/src/rules/__tests__/utils.test.ts

@@ -0,0 +1,160 @@
+import {
+  fieldNonEmpty,
+  matchesJsonSchemaType,
+  missingRequiredField,
+  oasTypeOf,
+  getAdditionalPropertiesOption,
+} from '../utils';
+
+describe('field-non-empty', () => {
+  it('should match expected message', () => {
+    const message = fieldNonEmpty('Car', 'color');
+    expect(message).toBe('Car object `color` must be non-empty string.');
+  });
+});
+
+describe('matches-json-schema-type', () => {
+  it('should report true on a null value with nullable type', () => {
+    const results = matchesJsonSchemaType(null, 'string', true);
+    expect(results).toBe(true);
+  });
+
+  it('should report true on a value and type integer', () => {
+    const results = matchesJsonSchemaType(123, 'integer', false);
+    expect(results).toBe(true);
+  });
+
+  it('should report false when the value is not integer and type is integer', () => {
+    const results = matchesJsonSchemaType(3.14, 'integer', false);
+    expect(results).toBe(false);
+  });
+
+  it('should report true when the value is a number and type is number', () => {
+    const results = matchesJsonSchemaType(3.14, 'number', false);
+    expect(results).toBe(true);
+  });
+
+  it('should report true when the value is an integer and type is number', () => {
+    const results = matchesJsonSchemaType(3, 'number', false);
+    expect(results).toBe(true);
+  });
+
+  it('should report true when the value is true and type is boolean', () => {
+    const results = matchesJsonSchemaType(true, 'boolean', false);
+    expect(results).toBe(true);
+  });
+
+  it('should report true when the value is false and type is boolean', () => {
+    const results = matchesJsonSchemaType(false, 'boolean', false);
+    expect(results).toBe(true);
+  });
+
+  it('should report true when the value is a string and type is boolean', () => {
+    const results = matchesJsonSchemaType('test', 'boolean', false);
+    expect(results).toBe(false);
+  });
+
+  it('should report true on an array value with array type', () => {
+    const results = matchesJsonSchemaType(['foo', 'bar'], 'array', false);
+    expect(results).toBe(true);
+  });
+
+  it('should report false on an array value with object type', () => {
+    const results = matchesJsonSchemaType(['foo', 'bar'], 'object', false);
+    expect(results).toBe(false);
+  });
+
+  it('should report true on an object value with object type', () => {
+    const car = { type: 'Fiat', model: '500', color: 'white' };
+    const results = matchesJsonSchemaType(car, 'object', true);
+    expect(results).toBe(true);
+  });
+
+  it('should report false on an object value with array type', () => {
+    const car = { type: 'Fiat', model: '500', color: 'white' };
+    const results = matchesJsonSchemaType(car, 'array', true);
+    expect(results).toBe(false);
+  });
+});
+
+describe('missing-required-field', () => {
+  it('should match expected message for missing required field', () => {
+    const message = missingRequiredField('Car', 'color');
+    expect(message).toBe('Car object should contain `color` field.');
+  });
+});
+
+describe('oas-type-of', () => {
+  it('should report the correct oas type for a string', () => {
+    const results = oasTypeOf('word');
+    expect(results).toBe('string');
+  });
+
+  it('should report the correct oas type for an integer', () => {
+    const results = oasTypeOf(123);
+    expect(results).toBe('integer');
+  });
+
+  it('should report the correct oas type for a number', () => {
+    const results = oasTypeOf(3.14);
+    expect(results).toBe('number');
+  });
+
+  it('should report the correct oas type for a null value', () => {
+    const results = oasTypeOf(null);
+    expect(results).toBe('null');
+  });
+
+  it('should report the correct oas type for a true boolean', () => {
+    const results = oasTypeOf(true);
+    expect(results).toBe('boolean');
+  });
+
+  it('should report the correct oas type for a false boolean', () => {
+    const results = oasTypeOf(false);
+    expect(results).toBe('boolean');
+  });
+
+  it('should report the correct oas type for an array', () => {
+    const results = oasTypeOf(['foo', 'bar']);
+    expect(results).toBe('array');
+  });
+
+  it('should report the correct oas type for an object', () => {
+    const car = { type: 'Fiat', model: '500', color: 'white' };
+    const results = oasTypeOf(car);
+    expect(results).toBe('object');
+  });
+});
+
+describe('get-additional-properties-option', () => {
+  it('should return actual option', () => {
+    const options = {
+      allowAdditionalProperties: true,
+    };
+    expect(getAdditionalPropertiesOption(options)).toBeTruthy();
+  });
+
+  it('should reverse option', () => {
+    const options = {
+      disallowAdditionalProperties: true,
+    };
+    expect(getAdditionalPropertiesOption(options)).toBeFalsy();
+  });
+
+  it('should throw error with message', () => {
+    const options = {
+      allowAdditionalProperties: true,
+      disallowAdditionalProperties: false,
+    };
+
+    try {
+      getAdditionalPropertiesOption(options);
+    } catch (error) {
+      expect(error).toBeInstanceOf(Error);
+      expect(error.message).toEqual(
+        "Do not use 'disallowAdditionalProperties' field. Use 'allowAdditionalProperties' instead. \n"
+      );
+    }
+  });
+});

package/src/rules/ajv.ts

@@ -0,0 +1,102 @@
+import Ajv, { ValidateFunction, ErrorObject } from '@redocly/ajv/dist/2020';
+import { Location, escapePointer } from '../ref-utils';
+import { ResolveFn } from '../walk';
+
+let ajvInstance: Ajv | null = null;
+
+export function releaseAjvInstance() {
+  ajvInstance = null;
+}
+
+function getAjv(resolve: ResolveFn, allowAdditionalProperties: boolean) {
+  if (!ajvInstance) {
+    ajvInstance = new Ajv({
+      schemaId: '$id',
+      meta: true,
+      allErrors: true,
+      strictSchema: false,
+      inlineRefs: false,
+      validateSchema: false,
+      discriminator: true,
+      allowUnionTypes: true,
+      validateFormats: false, // TODO: fix it
+      defaultUnevaluatedProperties: allowAdditionalProperties,
+      loadSchemaSync(base: string, $ref: string) {
+        const resolvedRef = resolve({ $ref }, base.split('#')[0]);
+        if (!resolvedRef || !resolvedRef.location) return false;
+        return { $id: resolvedRef.location.absolutePointer, ...resolvedRef.node };
+      },
+      logger: false,
+    });
+  }
+  return ajvInstance;
+}
+
+function getAjvValidator(
+  schema: any,
+  loc: Location,
+  resolve: ResolveFn,
+  allowAdditionalProperties: boolean
+): ValidateFunction | undefined {
+  const ajv = getAjv(resolve, allowAdditionalProperties);
+
+  if (!ajv.getSchema(loc.absolutePointer)) {
+    ajv.addSchema({ $id: loc.absolutePointer, ...schema }, loc.absolutePointer);
+  }
+
+  return ajv.getSchema(loc.absolutePointer);
+}
+
+export function validateJsonSchema(
+  data: any,
+  schema: any,
+  schemaLoc: Location,
+  instancePath: string,
+  resolve: ResolveFn,
+  allowAdditionalProperties: boolean
+): { valid: boolean; errors: (ErrorObject & { suggest?: string[] })[] } {
+  const validate = getAjvValidator(schema, schemaLoc, resolve, allowAdditionalProperties);
+  if (!validate) return { valid: true, errors: [] }; // unresolved refs are reported
+
+  const valid = validate(data, {
+    instancePath,
+    parentData: { fake: {} },
+    parentDataProperty: 'fake',
+    rootData: {},
+    dynamicAnchors: {},
+  });
+
+  return {
+    valid: !!valid,
+    errors: (validate.errors || []).map(beatifyErrorMessage),
+  };
+
+  function beatifyErrorMessage(error: ErrorObject) {
+    let message = error.message;
+    const suggest = error.keyword === 'enum' ? error.params.allowedValues : undefined;
+    if (suggest) {
+      message += ` ${suggest.map((e: any) => `"${e}"`).join(', ')}`;
+    }
+
+    if (error.keyword === 'type') {
+      message = `type ${message}`;
+    }
+
+    const relativePath = error.instancePath.substring(instancePath.length + 1);
+    const propName = relativePath.substring(relativePath.lastIndexOf('/') + 1);
+    if (propName) {
+      message = `\`${propName}\` property ${message}`;
+    }
+    if (error.keyword === 'additionalProperties' || error.keyword === 'unevaluatedProperties') {
+      const property = error.params.additionalProperty || error.params.unevaluatedProperty;
+      message = `${message} \`${property}\``;
+      error.instancePath += '/' + escapePointer(property);
+    }
+
+    return {
+      ...error,
+      message,
+      suggest,
+    };
+  }
+}

package/src/rules/common/__tests__/info-license.test.ts

@@ -0,0 +1,62 @@
+import { outdent } from 'outdent';
+import { lintDocument } from '../../../lint';
+import { parseYamlToDocument, replaceSourceWithRef, makeConfig } from '../../../../__tests__/utils';
+import { BaseResolver } from '../../../resolve';
+
+describe('Oas3 info-license', () => {
+  it('should report on info with no license', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+          openapi: 3.0.0
+          info:
+            version: '1.0'
+        `,
+      'foobar.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ 'info-license': 'error' }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/info",
+              "reportOnKey": true,
+              "source": "foobar.yaml",
+            },
+          ],
+          "message": "Info object should contain \`license\` field.",
+          "ruleId": "info-license",
+          "severity": "error",
+          "suggest": Array [],
+        },
+      ]
+    `);
+  });
+
+  it('should not report on info with license', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+          openapi: 3.0.0
+          info:
+            license:
+              name: MIT
+              url: google.com
+        `,
+      'foobar.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ 'info-license': 'error' }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`Array []`);
+  });
+});

package/src/rules/common/__tests__/license-url.test.ts

@@ -0,0 +1,63 @@
+import { outdent } from 'outdent';
+import { lintDocument } from '../../../lint';
+import { parseYamlToDocument, replaceSourceWithRef, makeConfig } from '../../../../__tests__/utils';
+import { BaseResolver } from '../../../resolve';
+
+describe('Oas3 license-url', () => {
+  it('should report on info.license with no url', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+          openapi: 3.0.0
+          info:
+            license:
+              name: MIT
+        `,
+      'foobar.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ 'info-license-url': 'error' }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/info/license/url",
+              "reportOnKey": true,
+              "source": "foobar.yaml",
+            },
+          ],
+          "message": "License object should contain \`url\` field.",
+          "ruleId": "info-license-url",
+          "severity": "error",
+          "suggest": Array [],
+        },
+      ]
+    `);
+  });
+
+  it('should not report on info.license with url', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+          openapi: 3.0.0
+          info:
+            license:
+              name: MIT
+              url: google.com
+        `,
+      'foobar.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ 'info-license-url': 'error' }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`Array []`);
+  });
+});