@redocly/openapi-core 1.18.1 → 1.20.0

package/src/rules/arazzo/__tests__/parameters-no-body-inside-in.test.ts

@@ -0,0 +1,76 @@
+import { outdent } from 'outdent';
+import { lintDocument } from '../../../lint';
+import { parseYamlToDocument, replaceSourceWithRef, makeConfig } from '../../../../__tests__/utils';
+import { BaseResolver } from '../../../resolve';
+import { StyleguideConfig } from '../../../config';
+import { ArazzoRule } from '../../../visitors';
+
+describe('Arazzo parameters-no-body-inside-in', () => {
+  const document = parseYamlToDocument(
+    outdent`
+      arazzo: '1.0.0'
+      info:
+        title: Cool API
+        version: 1.0.0
+        description: A cool API
+      sourceDescriptions:
+        - name: museum-api
+          type: openapi
+          url: openapi.yaml
+      workflows:
+        - workflowId: get-museum-hours
+          description: This workflow demonstrates how to get the museum opening hours and buy tickets.
+          parameters:
+            - in: body
+              name: Authorization
+              value: Basic Og==
+          steps:
+            - stepId: get-museum-hours
+              description: >-
+                Get museum hours by resolving request details with getMuseumHours operationId from openapi.yaml description.
+              operationId: museum-api.getMuseumHours
+              successCriteria:
+                - condition: $statusCode == 200
+    `,
+    'arazzo.yaml'
+  );
+
+  it('should not report on `body` inside parameter `in` field', async () => {
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ rules: {} }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`[]`);
+  });
+
+  it('should report on `body` inside parameter `in` field', async () => {
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({
+        rules: {},
+        arazzoRules: { 'parameters-no-body-inside-in': 'error' },
+      }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      [
+        {
+          "location": [
+            {
+              "pointer": "#/workflows/0/parameters/0/in",
+              "reportOnKey": false,
+              "source": "arazzo.yaml",
+            },
+          ],
+          "message": "The \`body\` value of the \`in\` property is not supported by Spot.",
+          "ruleId": "parameters-no-body-inside-in",
+          "severity": "error",
+          "suggest": [],
+        },
+      ]
+    `);
+  });
+});

package/src/rules/arazzo/index.ts

@@ -1,11 +1,14 @@
-import { ArazzoRule } from '../../visitors';
 import { Spec } from '../common/spec';
-import type { ArazzoRuleSet } from '../../oas-types';
 import { Assertions } from '../common/assertions';
+import { ParametersNoBodyInsideIn } from '../spot/parameters-no-body-inside-in';
+
+import type { ArazzoRule } from '../../visitors';
+import type { ArazzoRuleSet } from '../../oas-types';
 
 export const rules: ArazzoRuleSet<'built-in'> = {
   spec: Spec as ArazzoRule,
-  assertions: Assertions,
+  assertions: Assertions as ArazzoRule,
+  'parameters-no-body-inside-in': ParametersNoBodyInsideIn as ArazzoRule,
 };
 
 export const preprocessors = {};

package/src/rules/async2/__tests__/channels-kebab-case.test.ts

@@ -23,7 +23,7 @@ describe('Async2 channels-kebab-case', () => {
     const results = await lintDocument({
       externalRefResolver: new BaseResolver(),
       document,
-      config: await makeConfig({ 'channels-kebab-case': 'error' }),
+      config: await makeConfig({ rules: { 'channels-kebab-case': 'error' } }),
     });
 
     expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
@@ -64,7 +64,7 @@ describe('Async2 channels-kebab-case', () => {
     const results = await lintDocument({
       externalRefResolver: new BaseResolver(),
       document,
-      config: await makeConfig({ 'channels-kebab-case': 'error' }),
+      config: await makeConfig({ rules: { 'channels-kebab-case': 'error' } }),
     });
 
     expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
@@ -106,8 +106,10 @@ describe('Async2 channels-kebab-case', () => {
       externalRefResolver: new BaseResolver(),
       document,
       config: await makeConfig({
-        'paths-kebab-case': 'error',
-        'no-path-trailing-slash': 'off',
+        rules: {
+          'paths-kebab-case': 'error',
+          'no-path-trailing-slash': 'off',
+        },
       }),
     });
     expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`[]`);
@@ -133,7 +135,9 @@ describe('Async2 channels-kebab-case', () => {
       externalRefResolver: new BaseResolver(),
       document,
       config: await makeConfig({
-        'paths-kebab-case': 'error',
+        rules: {
+          'paths-kebab-case': 'error',
+        },
       }),
     });
     expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`[]`);

package/src/rules/async2/__tests__/no-channel-trailing-slash.test.ts

@@ -23,7 +23,7 @@ describe('no-channel-trailing-slash', () => {
     const results = await lintDocument({
       externalRefResolver: new BaseResolver(),
       document,
-      config: await makeConfig({ 'no-channel-trailing-slash': 'error' }),
+      config: await makeConfig({ rules: { 'no-channel-trailing-slash': 'error' } }),
     });
 
     expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
@@ -64,7 +64,7 @@ describe('no-channel-trailing-slash', () => {
     const results = await lintDocument({
       externalRefResolver: new BaseResolver(),
       document,
-      config: await makeConfig({ 'no-channel-trailing-slash': 'error' }),
+      config: await makeConfig({ rules: { 'no-channel-trailing-slash': 'error' } }),
     });
 
     expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`[]`);
@@ -89,7 +89,7 @@ describe('no-channel-trailing-slash', () => {
     const results = await lintDocument({
       externalRefResolver: new BaseResolver(),
       document,
-      config: await makeConfig({ 'no-channel-trailing-slash': 'error' }),
+      config: await makeConfig({ rules: { 'no-channel-trailing-slash': 'error' } }),
     });
 
     expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`[]`);

package/src/rules/async2/channels-kebab-case.ts

@@ -1,5 +1,5 @@
-import { Async2Rule } from '../../visitors';
-import { UserContext } from '../../walk';
+import type { Async2Rule } from '../../visitors';
+import type { UserContext } from '../../walk';
 
 export const ChannelsKebabCase: Async2Rule = () => {
   return {

package/src/rules/async2/index.ts

@@ -1,23 +1,26 @@
-import { Async2Rule } from '../../visitors';
 import { Assertions } from '../common/assertions';
 import { Spec } from '../common/spec';
 import { InfoContact } from '../common/info-contact';
+import { InfoLicenseStrict } from '../common/info-license-strict';
 import { OperationOperationId } from '../common/operation-operationId';
 import { TagDescription } from '../common/tag-description';
 import { TagsAlphabetical } from '../common/tags-alphabetical';
 import { ChannelsKebabCase } from './channels-kebab-case';
 import { NoChannelTrailingSlash } from './no-channel-trailing-slash';
+
+import type { Async2Rule } from '../../visitors';
 import type { Async2RuleSet } from '../../oas-types';
 
 export const rules: Async2RuleSet<'built-in'> = {
   spec: Spec as Async2Rule,
-  assertions: Assertions,
-  'info-contact': InfoContact,
-  'operation-operationId': OperationOperationId,
+  assertions: Assertions as Async2Rule,
+  'info-contact': InfoContact as Async2Rule,
+  'info-license-strict': InfoLicenseStrict as Async2Rule,
+  'operation-operationId': OperationOperationId as Async2Rule,
   'channels-kebab-case': ChannelsKebabCase,
   'no-channel-trailing-slash': NoChannelTrailingSlash,
-  'tag-description': TagDescription,
-  'tags-alphabetical': TagsAlphabetical,
+  'tag-description': TagDescription as Async2Rule,
+  'tags-alphabetical': TagsAlphabetical as Async2Rule,
 };
 
 export const preprocessors = {};

package/src/rules/async2/no-channel-trailing-slash.ts

@@ -1,5 +1,5 @@
-import { Async2Rule } from '../../visitors';
-import { UserContext } from '../../walk';
+import type { Async2Rule } from '../../visitors';
+import type { UserContext } from '../../walk';
 
 export const NoChannelTrailingSlash: Async2Rule = () => {
   return {

package/src/rules/async3/__tests__/channels-kebab-case.test.ts

@@ -0,0 +1,145 @@
+import { outdent } from 'outdent';
+import { lintDocument } from '../../../lint';
+import { parseYamlToDocument, replaceSourceWithRef, makeConfig } from '../../../../__tests__/utils';
+import { BaseResolver } from '../../../resolve';
+
+describe('Async2 channels-kebab-case', () => {
+  it('should report on no kebab-case channel path', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+        asyncapi: '3.0.0'
+        info:
+          title: Cool API
+          version: 1.0.0
+        channels:
+          channel1:
+            address: /NOT_A_KEBAB/
+            payload:
+              type: object
+        `,
+      'asyncapi.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ rules: { 'channels-kebab-case': 'error' } }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      [
+        {
+          "location": [
+            {
+              "pointer": "#/channels/channel1",
+              "reportOnKey": true,
+              "source": "asyncapi.yaml",
+            },
+          ],
+          "message": "\`/NOT_A_KEBAB/\` does not use kebab-case.",
+          "ruleId": "channels-kebab-case",
+          "severity": "error",
+          "suggest": [],
+        },
+      ]
+    `);
+  });
+
+  it('should report on snake_case in channel path', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+        asyncapi: '3.0.0'
+        info:
+          title: Cool API
+          version: 1.0.0
+        channels:
+          channel1:
+            address: snake_kebab
+            payload:
+              type: object
+        `,
+      'asyncapi.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ rules: { 'channels-kebab-case': 'error' } }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      [
+        {
+          "location": [
+            {
+              "pointer": "#/channels/channel1",
+              "reportOnKey": true,
+              "source": "asyncapi.yaml",
+            },
+          ],
+          "message": "\`snake_kebab\` does not use kebab-case.",
+          "ruleId": "channels-kebab-case",
+          "severity": "error",
+          "suggest": [],
+        },
+      ]
+    `);
+  });
+
+  it('should allow trailing slash in channel path with "channels-kebab-case" rule', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+        asyncapi: '3.0.0'
+        info:
+          title: Cool API
+          version: 1.0.0
+        channels:
+          channel1:
+            address: kebab/
+            payload:
+              type: object
+        `,
+      'asyncapi.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({
+        rules: {
+          'paths-kebab-case': 'error',
+          'no-path-trailing-slash': 'off',
+        },
+      }),
+    });
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`[]`);
+  });
+
+  it('words with hyphens are allowed with "channels-kebab-case" rule', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+        asyncapi: '3.0.0'
+        info:
+          title: Cool API
+          version: 1.0.0
+        channels:
+          channel1:
+            address: kebab-with-longer-channel-path:/
+            payload:
+              type: object
+        `,
+      'asyncapi.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({
+        rules: {
+          'paths-kebab-case': 'error',
+        },
+      }),
+    });
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`[]`);
+  });
+});

package/src/rules/async3/__tests__/no-channel-trailing-slash.test.ts

@@ -0,0 +1,96 @@
+import { outdent } from 'outdent';
+import { lintDocument } from '../../../lint';
+import { parseYamlToDocument, replaceSourceWithRef, makeConfig } from '../../../../__tests__/utils';
+import { BaseResolver } from '../../../resolve';
+
+describe('no-channel-trailing-slash', () => {
+  it.only('should report on trailing slash in a channel path', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+          asyncapi: '3.0.0'
+          info:
+            title: Excellent API
+            version: 1.0.0
+          channels:
+            channel1:
+              address: /trailing/
+              payload:
+                type: object
+        `,
+      'asyncapi.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ rules: { 'no-channel-trailing-slash': 'error' } }),
+    });
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      [
+        {
+          "location": [
+            {
+              "pointer": "#/channels/channel1",
+              "reportOnKey": true,
+              "source": "asyncapi.yaml",
+            },
+          ],
+          "message": "\`/trailing/\` should not have a trailing slash.",
+          "ruleId": "no-channel-trailing-slash",
+          "severity": "error",
+          "suggest": [],
+        },
+      ]
+    `);
+  });
+
+  it('should not report on if no trailing slash in path', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+          asyncapi: '3.0.0'
+          info:
+            title: Excellent API
+            version: 1.0.0
+          channels:
+            channel1:
+            address: /expected
+            payload:
+              type: object
+        `,
+      'asyncapi.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ rules: { 'no-channel-trailing-slash': 'error' } }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`[]`);
+  });
+
+  it('should not report on trailing slash in path if the path is root', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+          asyncapi: '3.0.0'
+          info:
+            title: Excellent API
+            version: 1.0.0
+          channels:
+            channel1:
+            address: /
+            payload:
+              type: object
+        `,
+      'foobar.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ rules: { 'no-channel-trailing-slash': 'error' } }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`[]`);
+  });
+});

package/src/rules/async3/channels-kebab-case.ts

@@ -0,0 +1,19 @@
+import type { Channel } from '../../typings/asyncapi3';
+import type { Async3Rule } from '../../visitors';
+import type { UserContext } from '../../walk';
+
+export const ChannelsKebabCase: Async3Rule = () => {
+  return {
+    Channel(channel: Channel, { report }: UserContext) {
+      const segments = (channel.address || '')
+        .split(/[/.:]/) // split on / or : as likely channel namespacers
+        .filter((s) => s !== ''); // filter out empty segments
+      if (!segments.every((segment) => /^{.+}$/.test(segment) || /^[a-z0-9-.]+$/.test(segment))) {
+        report({
+          message: `\`${channel.address}\` does not use kebab-case.`,
+          location: { reportOnKey: true },
+        });
+      }
+    },
+  };
+};

package/src/rules/async3/index.ts

@@ -0,0 +1,26 @@
+import { Assertions } from '../common/assertions';
+import { Spec } from '../common/spec';
+import { InfoContact } from '../common/info-contact';
+import { InfoLicenseStrict } from '../common/info-license-strict';
+import { OperationOperationId } from '../common/operation-operationId';
+import { TagDescription } from '../common/tag-description';
+import { TagsAlphabetical } from '../common/tags-alphabetical';
+import { ChannelsKebabCase } from './channels-kebab-case';
+import { NoChannelTrailingSlash } from './no-channel-trailing-slash';
+
+import type { Async3Rule } from '../../visitors';
+import type { Async3RuleSet } from '../../oas-types';
+
+export const rules: Async3RuleSet<'built-in'> = {
+  spec: Spec as Async3Rule,
+  assertions: Assertions as Async3Rule,
+  'info-contact': InfoContact as Async3Rule,
+  'info-license-strict': InfoLicenseStrict as Async3Rule,
+  'operation-operationId': OperationOperationId as Async3Rule,
+  'channels-kebab-case': ChannelsKebabCase,
+  'no-channel-trailing-slash': NoChannelTrailingSlash,
+  'tag-description': TagDescription as Async3Rule,
+  'tags-alphabetical': TagsAlphabetical as Async3Rule,
+};
+
+export const preprocessors = {};

package/src/rules/async3/no-channel-trailing-slash.ts

@@ -0,0 +1,16 @@
+import type { Async3Rule } from '../../visitors';
+import type { UserContext } from '../../walk';
+import type { Channel } from '../../typings/asyncapi3';
+
+export const NoChannelTrailingSlash: Async3Rule = () => {
+  return {
+    Channel(channel: Channel, { report, location }: UserContext) {
+      if ((channel.address as string).endsWith('/') && channel.address !== '/') {
+        report({
+          message: `\`${channel.address}\` should not have a trailing slash.`,
+          location: location.key(),
+        });
+      }
+    },
+  };
+};

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

@@ -0,0 +1,141 @@
+import { outdent } from 'outdent';
+import { lintDocument } from '../../../lint';
+import { parseYamlToDocument, replaceSourceWithRef, makeConfig } from '../../../../__tests__/utils';
+import { BaseResolver } from '../../../resolve';
+
+describe('license-strict', () => {
+  it('should report on info.license with no url or identifier for OpenAPI 3.1', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+          openapi: 3.1.0
+          info:
+            license:
+              name: MIT
+        `,
+      'foobar.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ rules: { 'info-license-strict': 'error' } }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      [
+        {
+          "location": [
+            {
+              "pointer": "#/info/license",
+              "reportOnKey": true,
+              "source": "foobar.yaml",
+            },
+          ],
+          "message": "License object should contain one of the fields: \`url\`, \`identifier\`.",
+          "ruleId": "info-license-strict",
+          "severity": "error",
+          "suggest": [],
+        },
+      ]
+    `);
+  });
+
+  it('should not report on info.license with url for OpenAPI 3.1', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+          openapi: 3.1.0
+          info:
+            license:
+              name: MIT
+              url: google.com
+        `,
+      'foobar.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ rules: { 'info-license-strict': 'error' } }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`[]`);
+  });
+
+  it('should not report on info.license with identifier', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+          openapi: 3.1.0
+          info:
+            license:
+              name: MIT
+              identifier: MIT
+        `,
+      'foobar.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ rules: { 'info-license-strict': 'error' } }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`[]`);
+  });
+
+  it('should report on info.license with no url for AsyncAPI 3.0', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+            asyncapi: 3.0.0
+            info:
+              license:
+                name: MIT
+          `,
+      'foobar.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ rules: { 'info-license-strict': 'error' } }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      [
+        {
+          "location": [
+            {
+              "pointer": "#/info/license/url",
+              "reportOnKey": true,
+              "source": "foobar.yaml",
+            },
+          ],
+          "message": "License object should contain \`url\` field.",
+          "ruleId": "info-license-strict",
+          "severity": "error",
+          "suggest": [],
+        },
+      ]
+    `);
+  });
+
+  it('should not report on info.license with url for AsyncAPI 3.0', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+            asyncapi: 3.0.0
+            info:
+              license:
+                name: MIT
+                url: google.com
+          `,
+      'foobar.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ rules: { 'info-license-strict': 'error' } }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`[]`);
+  });
+});

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

@@ -17,7 +17,7 @@ describe('Oas3 info-license', () => {
     const results = await lintDocument({
       externalRefResolver: new BaseResolver(),
       document,
-      config: await makeConfig({ 'info-license': 'error' }),
+      config: await makeConfig({ rules: { 'info-license': 'error' } }),
     });
 
     expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
@@ -54,7 +54,7 @@ describe('Oas3 info-license', () => {
     const results = await lintDocument({
       externalRefResolver: new BaseResolver(),
       document,
-      config: await makeConfig({ 'info-license': 'error' }),
+      config: await makeConfig({ rules: { 'info-license': 'error' } }),
     });
 
     expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`[]`);