@redocly/openapi-core 1.1.0 → 1.2.0

package/src/config/config.ts

@@ -3,7 +3,13 @@ import * as path from 'path';
 import { parseYaml, stringifyYaml } from '../js-yaml';
 import { slash, doesYamlFileExist } from '../utils';
 import { NormalizedProblem } from '../walk';
-import { OasVersion, OasMajorVersion, Oas2RuleSet, Oas3RuleSet } from '../oas-types';
+import {
+  SpecVersion,
+  SpecMajorVersion,
+  Oas2RuleSet,
+  Oas3RuleSet,
+  Async2RuleSet,
+} from '../oas-types';
 import { isBrowser, env } from '../env';
 
 import type { NodeType } from '../types';
@@ -65,12 +71,12 @@ export class StyleguideConfig {
   plugins: Plugin[];
   ignore: Record<string, Record<string, Set<string>>> = {};
   doNotResolveExamples: boolean;
-  rules: Record<OasVersion, Record<string, RuleConfig>>;
-  preprocessors: Record<OasVersion, Record<string, PreprocessorConfig>>;
-  decorators: Record<OasVersion, Record<string, DecoratorConfig>>;
+  rules: Record<SpecVersion, Record<string, RuleConfig>>;
+  preprocessors: Record<SpecVersion, Record<string, PreprocessorConfig>>;
+  decorators: Record<SpecVersion, Record<string, DecoratorConfig>>;
 
   private _usedRules: Set<string> = new Set();
-  private _usedVersions: Set<OasVersion> = new Set();
+  private _usedVersions: Set<SpecVersion> = new Set();
 
   recommendedFallback: boolean;
 
@@ -83,21 +89,24 @@ export class StyleguideConfig {
     this.recommendedFallback = rawConfig.recommendedFallback || false;
 
     this.rules = {
-      [OasVersion.Version2]: { ...rawConfig.rules, ...rawConfig.oas2Rules },
-      [OasVersion.Version3_0]: { ...rawConfig.rules, ...rawConfig.oas3_0Rules },
-      [OasVersion.Version3_1]: { ...rawConfig.rules, ...rawConfig.oas3_1Rules },
+      [SpecVersion.OAS2]: { ...rawConfig.rules, ...rawConfig.oas2Rules },
+      [SpecVersion.OAS3_0]: { ...rawConfig.rules, ...rawConfig.oas3_0Rules },
+      [SpecVersion.OAS3_1]: { ...rawConfig.rules, ...rawConfig.oas3_1Rules },
+      [SpecVersion.Async2]: { ...rawConfig.rules, ...rawConfig.async2Rules },
     };
 
     this.preprocessors = {
-      [OasVersion.Version2]: { ...rawConfig.preprocessors, ...rawConfig.oas2Preprocessors },
-      [OasVersion.Version3_0]: { ...rawConfig.preprocessors, ...rawConfig.oas3_0Preprocessors },
-      [OasVersion.Version3_1]: { ...rawConfig.preprocessors, ...rawConfig.oas3_1Preprocessors },
+      [SpecVersion.OAS2]: { ...rawConfig.preprocessors, ...rawConfig.oas2Preprocessors },
+      [SpecVersion.OAS3_0]: { ...rawConfig.preprocessors, ...rawConfig.oas3_0Preprocessors },
+      [SpecVersion.OAS3_1]: { ...rawConfig.preprocessors, ...rawConfig.oas3_1Preprocessors },
+      [SpecVersion.Async2]: { ...rawConfig.preprocessors, ...rawConfig.async2Preprocessors },
     };
 
     this.decorators = {
-      [OasVersion.Version2]: { ...rawConfig.decorators, ...rawConfig.oas2Decorators },
-      [OasVersion.Version3_0]: { ...rawConfig.decorators, ...rawConfig.oas3_0Decorators },
-      [OasVersion.Version3_1]: { ...rawConfig.decorators, ...rawConfig.oas3_1Decorators },
+      [SpecVersion.OAS2]: { ...rawConfig.decorators, ...rawConfig.oas2Decorators },
+      [SpecVersion.OAS3_0]: { ...rawConfig.decorators, ...rawConfig.oas3_0Decorators },
+      [SpecVersion.OAS3_1]: { ...rawConfig.decorators, ...rawConfig.oas3_1Decorators },
+      [SpecVersion.Async2]: { ...rawConfig.decorators, ...rawConfig.async2Decorators },
     };
 
     this.extendPaths = rawConfig.extendPaths || [];
@@ -173,20 +182,24 @@ export class StyleguideConfig {
       : problem;
   }
 
-  extendTypes(types: Record<string, NodeType>, version: OasVersion) {
+  extendTypes(types: Record<string, NodeType>, version: SpecVersion) {
     let extendedTypes = types;
     for (const plugin of this.plugins) {
       if (plugin.typeExtension !== undefined) {
         switch (version) {
-          case OasVersion.Version3_0:
-          case OasVersion.Version3_1:
+          case SpecVersion.OAS3_0:
+          case SpecVersion.OAS3_1:
             if (!plugin.typeExtension.oas3) continue;
             extendedTypes = plugin.typeExtension.oas3(extendedTypes, version);
             break;
-          case OasVersion.Version2:
+          case SpecVersion.OAS2:
             if (!plugin.typeExtension.oas2) continue;
             extendedTypes = plugin.typeExtension.oas2(extendedTypes, version);
             break;
+          case SpecVersion.Async2:
+            if (!plugin.typeExtension.async2) continue;
+            extendedTypes = plugin.typeExtension.async2(extendedTypes, version);
+            break;
           default:
             throw new Error('Not implemented');
         }
@@ -195,7 +208,7 @@ export class StyleguideConfig {
     return extendedTypes;
   }
 
-  getRuleSettings(ruleId: string, oasVersion: OasVersion): RuleSettings {
+  getRuleSettings(ruleId: string, oasVersion: SpecVersion): RuleSettings {
     this._usedRules.add(ruleId);
     this._usedVersions.add(oasVersion);
     const settings = this.rules[oasVersion][ruleId] || 'off';
@@ -208,7 +221,7 @@ export class StyleguideConfig {
     }
   }
 
-  getPreprocessorSettings(ruleId: string, oasVersion: OasVersion): RuleSettings {
+  getPreprocessorSettings(ruleId: string, oasVersion: SpecVersion): RuleSettings {
     this._usedRules.add(ruleId);
     this._usedVersions.add(oasVersion);
 
@@ -222,7 +235,7 @@ export class StyleguideConfig {
     }
   }
 
-  getDecoratorSettings(ruleId: string, oasVersion: OasVersion): RuleSettings {
+  getDecoratorSettings(ruleId: string, oasVersion: SpecVersion): RuleSettings {
     this._usedRules.add(ruleId);
     this._usedVersions.add(oasVersion);
     const settings = this.decorators[oasVersion][ruleId] || 'off';
@@ -259,28 +272,39 @@ export class StyleguideConfig {
     };
   }
 
-  getRulesForOasVersion(version: OasMajorVersion) {
+  getRulesForOasVersion(version: SpecMajorVersion) {
     switch (version) {
-      case OasMajorVersion.Version3:
+      case SpecMajorVersion.OAS3:
         // eslint-disable-next-line no-case-declarations
         const oas3Rules: Oas3RuleSet[] = []; // default ruleset
         this.plugins.forEach((p) => p.preprocessors?.oas3 && oas3Rules.push(p.preprocessors.oas3));
         this.plugins.forEach((p) => p.rules?.oas3 && oas3Rules.push(p.rules.oas3));
         this.plugins.forEach((p) => p.decorators?.oas3 && oas3Rules.push(p.decorators.oas3));
         return oas3Rules;
-      case OasMajorVersion.Version2:
+      case SpecMajorVersion.OAS2:
         // eslint-disable-next-line no-case-declarations
         const oas2Rules: Oas2RuleSet[] = []; // default ruleset
         this.plugins.forEach((p) => p.preprocessors?.oas2 && oas2Rules.push(p.preprocessors.oas2));
         this.plugins.forEach((p) => p.rules?.oas2 && oas2Rules.push(p.rules.oas2));
         this.plugins.forEach((p) => p.decorators?.oas2 && oas2Rules.push(p.decorators.oas2));
         return oas2Rules;
+      case SpecMajorVersion.Async2:
+        // eslint-disable-next-line no-case-declarations
+        const asyncApiRules: Async2RuleSet[] = []; // default ruleset
+        this.plugins.forEach(
+          (p) => p.preprocessors?.async2 && asyncApiRules.push(p.preprocessors.async2)
+        );
+        this.plugins.forEach((p) => p.rules?.async2 && asyncApiRules.push(p.rules.async2));
+        this.plugins.forEach(
+          (p) => p.decorators?.async2 && asyncApiRules.push(p.decorators.async2)
+        );
+        return asyncApiRules;
     }
   }
 
   skipRules(rules?: string[]) {
     for (const ruleId of rules || []) {
-      for (const version of Object.values(OasVersion)) {
+      for (const version of Object.values(SpecVersion)) {
         if (this.rules[version][ruleId]) {
           this.rules[version][ruleId] = 'off';
         }
@@ -290,7 +314,7 @@ export class StyleguideConfig {
 
   skipPreprocessors(preprocessors?: string[]) {
     for (const preprocessorId of preprocessors || []) {
-      for (const version of Object.values(OasVersion)) {
+      for (const version of Object.values(SpecVersion)) {
         if (this.preprocessors[version][preprocessorId]) {
           this.preprocessors[version][preprocessorId] = 'off';
         }
@@ -300,7 +324,7 @@ export class StyleguideConfig {
 
   skipDecorators(decorators?: string[]) {
     for (const decoratorId of decorators || []) {
-      for (const version of Object.values(OasVersion)) {
+      for (const version of Object.values(SpecVersion)) {
         if (this.decorators[version][decoratorId]) {
           this.decorators[version][decoratorId] = 'off';
         }

package/src/config/rules.ts

@@ -1,4 +1,4 @@
-import { RuleSet, OasVersion } from '../oas-types';
+import { RuleSet, SpecVersion } from '../oas-types';
 import { StyleguideConfig } from './config';
 import { isDefined } from '../utils';
 import type { ProblemSeverity } from '../walk';
@@ -13,7 +13,7 @@ export function initRules<T extends Function, P extends RuleSet<T>>(
   rules: P[],
   config: StyleguideConfig,
   type: 'rules' | 'preprocessors' | 'decorators',
-  oasVersion: OasVersion
+  oasVersion: SpecVersion
 ): InitializedRule[] {
   return rules
     .flatMap((ruleset) =>

package/src/config/types.ts

@@ -1,14 +1,18 @@
 import type { ProblemSeverity, UserContext } from '../walk';
 import type {
   Oas3PreprocessorsSet,
-  OasMajorVersion,
+  SpecMajorVersion,
   Oas3DecoratorsSet,
   Oas2RuleSet,
   Oas2PreprocessorsSet,
   Oas2DecoratorsSet,
   Oas3RuleSet,
-  OasVersion,
+  SpecVersion,
+  Async2PreprocessorsSet,
+  Async2DecoratorsSet,
+  Async2RuleSet,
 } from '../oas-types';
+
 import type { NodeType } from '../types';
 import { Location } from '../ref-utils';
 import type { SkipFunctionContext } from '../visitors';
@@ -43,16 +47,19 @@ export type StyleguideRawConfig = {
   oas2Rules?: Record<string, RuleConfig>;
   oas3_0Rules?: Record<string, RuleConfig>;
   oas3_1Rules?: Record<string, RuleConfig>;
+  async2Rules?: Record<string, RuleConfig>;
 
   preprocessors?: Record<string, PreprocessorConfig>;
   oas2Preprocessors?: Record<string, PreprocessorConfig>;
   oas3_0Preprocessors?: Record<string, PreprocessorConfig>;
   oas3_1Preprocessors?: Record<string, PreprocessorConfig>;
+  async2Preprocessors?: Record<string, PreprocessorConfig>;
 
   decorators?: Record<string, DecoratorConfig>;
   oas2Decorators?: Record<string, DecoratorConfig>;
   oas3_0Decorators?: Record<string, DecoratorConfig>;
   oas3_1Decorators?: Record<string, DecoratorConfig>;
+  async2Decorators?: Record<string, DecoratorConfig>;
 };
 
 export type ApiStyleguideRawConfig = Omit<StyleguideRawConfig, 'plugins'>;
@@ -68,23 +75,26 @@ export type ResolvedStyleguideConfig = PluginStyleguideConfig & {
 export type PreprocessorsConfig = {
   oas3?: Oas3PreprocessorsSet;
   oas2?: Oas2PreprocessorsSet;
+  async2?: Async2PreprocessorsSet;
 };
 
 export type DecoratorsConfig = {
   oas3?: Oas3DecoratorsSet;
   oas2?: Oas2DecoratorsSet;
+  async2?: Async2DecoratorsSet;
 };
 
 export type TypesExtensionFn = (
   types: Record<string, NodeType>,
-  oasVersion: OasVersion
+  oasVersion: SpecVersion
 ) => Record<string, NodeType>;
 
-export type TypeExtensionsConfig = Partial<Record<OasMajorVersion, TypesExtensionFn>>;
+export type TypeExtensionsConfig = Partial<Record<SpecMajorVersion, TypesExtensionFn>>;
 
 export type CustomRulesConfig = {
   oas3?: Oas3RuleSet;
   oas2?: Oas2RuleSet;
+  async2?: Async2RuleSet;
 };
 
 export type AssertionContext = Partial<UserContext> & SkipFunctionContext & { node: any };

package/src/index.ts

@@ -52,7 +52,13 @@ export {
 } from './resolve';
 export { parseYaml, stringifyYaml } from './js-yaml';
 export { unescapePointer, isRef, isAbsoluteUrl } from './ref-utils';
-export { detectOpenAPI, OasMajorVersion, openAPIMajor, OasVersion } from './oas-types';
+export {
+  SpecMajorVersion,
+  getMajorSpecVersion,
+  SpecVersion,
+  detectSpec,
+  getTypes,
+} from './oas-types';
 export { normalizeVisitors } from './visitors';
 
 export {

package/src/lint.ts

@@ -1,16 +1,13 @@
 import { BaseResolver, resolveDocument, Document, makeDocumentFromString } from './resolve';
 import { normalizeVisitors } from './visitors';
-import { Oas3_1Types } from './types/oas3_1';
-import { Oas3Types } from './types/oas3';
-import { Oas2Types } from './types/oas2';
 import { NodeType } from './types';
 import { ProblemSeverity, WalkContext, walkDocument } from './walk';
 import { StyleguideConfig, Config, initRules, defaultPlugin, resolvePlugins } from './config';
 import { normalizeTypes } from './types';
 import { releaseAjvInstance } from './rules/ajv';
-import { detectOpenAPI, Oas3RuleSet, OasMajorVersion, OasVersion, openAPIMajor } from './oas-types';
+import { Oas3RuleSet, SpecVersion, getMajorSpecVersion, detectSpec, getTypes } from './oas-types';
 import { ConfigTypes } from './types/redocly-yaml';
-import { OasSpec } from './rules/common/spec';
+import { Spec } from './rules/common/spec';
 
 export async function lint(opts: {
   ref: string;
@@ -54,29 +51,22 @@ export async function lintDocument(opts: {
   releaseAjvInstance(); // FIXME: preprocessors can modify nodes which are then cached to ajv-instance by absolute path
 
   const { document, customTypes, externalRefResolver, config } = opts;
-  const oasVersion = detectOpenAPI(document.parsed);
-  const oasMajorVersion = openAPIMajor(oasVersion);
-  const rules = config.getRulesForOasVersion(oasMajorVersion);
+  const specVersion = detectSpec(document.parsed);
+  const specMajorVersion = getMajorSpecVersion(specVersion);
+  const rules = config.getRulesForOasVersion(specMajorVersion);
   const types = normalizeTypes(
-    config.extendTypes(
-      customTypes ?? oasMajorVersion === OasMajorVersion.Version3
-        ? oasVersion === OasVersion.Version3_1
-          ? Oas3_1Types
-          : Oas3Types
-        : Oas2Types,
-      oasVersion
-    ),
+    config.extendTypes(customTypes ?? getTypes(specVersion), specVersion),
     config
   );
 
   const ctx: WalkContext = {
     problems: [],
-    oasVersion: oasVersion,
+    oasVersion: specVersion,
     visitorsData: {},
   };
 
-  const preprocessors = initRules(rules as any, config, 'preprocessors', oasVersion);
-  const regularRules = initRules(rules as Oas3RuleSet[], config, 'rules', oasVersion);
+  const preprocessors = initRules(rules as any, config, 'preprocessors', specVersion);
+  const regularRules = initRules(rules as Oas3RuleSet[], config, 'rules', specVersion);
 
   let resolvedRefMap = await resolveDocument({
     rootDocument: document,
@@ -117,7 +107,7 @@ export async function lintConfig(opts: { document: Document; severity?: ProblemS
 
   const ctx: WalkContext = {
     problems: [],
-    oasVersion: OasVersion.Version3_0,
+    oasVersion: SpecVersion.OAS3_0,
     visitorsData: {},
   };
   const plugins = resolvePlugins([defaultPlugin]);
@@ -131,10 +121,11 @@ export async function lintConfig(opts: { document: Document; severity?: ProblemS
     {
       severity: severity || 'error',
       ruleId: 'configuration spec',
-      visitor: OasSpec({ severity: 'error' }),
+      visitor: Spec({ severity: 'error' }),
     },
   ];
-  const normalizedVisitors = normalizeVisitors(rules, types);
+  // TODO: check why any is needed
+  const normalizedVisitors = normalizeVisitors(rules as any, types);
 
   walkDocument({
     document,

package/src/oas-types.ts

@@ -1,57 +1,95 @@
-import { Oas3Rule, Oas3Preprocessor, Oas2Rule, Oas2Preprocessor } from './visitors';
+import {
+  Oas3Rule,
+  Oas3Preprocessor,
+  Oas2Rule,
+  Oas2Preprocessor,
+  Async2Preprocessor,
+  Async2Rule,
+} from './visitors';
+import { Oas2Types } from './types/oas2';
+import { Oas3Types } from './types/oas3';
+import { Oas3_1Types } from './types/oas3_1';
+import { AsyncApi2Types } from './types/asyncapi';
 
 export type RuleSet<T> = Record<string, T>;
 
-export enum OasVersion {
-  Version2 = 'oas2',
-  Version3_0 = 'oas3_0',
-  Version3_1 = 'oas3_1',
+export enum SpecVersion {
+  OAS2 = 'oas2',
+  OAS3_0 = 'oas3_0',
+  OAS3_1 = 'oas3_1',
+  Async2 = 'async2', // todo split into 2.x maybe?
 }
 
-export enum OasMajorVersion {
-  Version2 = 'oas2',
-  Version3 = 'oas3',
+export enum SpecMajorVersion {
+  OAS2 = 'oas2',
+  OAS3 = 'oas3',
+  Async2 = 'async2',
 }
 
+const typesMap = {
+  [SpecVersion.OAS2]: Oas2Types,
+  [SpecVersion.OAS3_0]: Oas3Types,
+  [SpecVersion.OAS3_1]: Oas3_1Types,
+  [SpecVersion.Async2]: AsyncApi2Types,
+};
+
 export type Oas3RuleSet = Record<string, Oas3Rule>;
 export type Oas2RuleSet = Record<string, Oas2Rule>;
+export type Async2RuleSet = Record<string, Async2Rule>;
 export type Oas3PreprocessorsSet = Record<string, Oas3Preprocessor>;
 export type Oas2PreprocessorsSet = Record<string, Oas2Preprocessor>;
+export type Async2PreprocessorsSet = Record<string, Async2Preprocessor>;
 export type Oas3DecoratorsSet = Record<string, Oas3Preprocessor>;
 export type Oas2DecoratorsSet = Record<string, Oas2Preprocessor>;
+export type Async2DecoratorsSet = Record<string, Async2Preprocessor>;
 
-export function detectOpenAPI(root: any): OasVersion {
+export function detectSpec(root: any): SpecVersion {
   if (typeof root !== 'object') {
     throw new Error(`Document must be JSON object, got ${typeof root}`);
   }
 
-  if (!(root.openapi || root.swagger)) {
-    throw new Error('This doesn’t look like an OpenAPI document.\n');
-  }
-
   if (root.openapi && typeof root.openapi !== 'string') {
     throw new Error(`Invalid OpenAPI version: should be a string but got "${typeof root.openapi}"`);
   }
 
   if (root.openapi && root.openapi.startsWith('3.0')) {
-    return OasVersion.Version3_0;
+    return SpecVersion.OAS3_0;
   }
 
   if (root.openapi && root.openapi.startsWith('3.1')) {
-    return OasVersion.Version3_1;
+    return SpecVersion.OAS3_1;
   }
 
   if (root.swagger && root.swagger === '2.0') {
-    return OasVersion.Version2;
+    return SpecVersion.OAS2;
   }
 
-  throw new Error(`Unsupported OpenAPI Version: ${root.openapi || root.swagger}`);
+  // if not detected yet
+  if (root.openapi || root.swagger) {
+    throw new Error(`Unsupported OpenAPI version: ${root.openapi || root.swagger}`);
+  }
+
+  if (root.asyncapi && root.asyncapi.startsWith('2.')) {
+    return SpecVersion.Async2;
+  }
+
+  if (root.asyncapi) {
+    throw new Error(`Unsupported AsyncAPI version: ${root.asyncapi}`);
+  }
+
+  throw new Error(`Unsupported specification`);
 }
 
-export function openAPIMajor(version: OasVersion): OasMajorVersion {
-  if (version === OasVersion.Version2) {
-    return OasMajorVersion.Version2;
+export function getMajorSpecVersion(version: SpecVersion): SpecMajorVersion {
+  if (version === SpecVersion.OAS2) {
+    return SpecMajorVersion.OAS2;
+  } else if (version === SpecVersion.Async2) {
+    return SpecMajorVersion.Async2;
   } else {
-    return OasMajorVersion.Version3;
+    return SpecMajorVersion.OAS3;
   }
 }
+
+export function getTypes(spec: SpecVersion) {
+  return typesMap[spec];
+}

package/src/rules/async2/__tests__/channels-kebab-case.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('Async2 channels-kebab-case', () => {
+  it('should report on no kebab-case channel path', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+        asyncapi: '2.6.0'
+        info:
+          title: Cool API
+          version: 1.0.0
+        channels:
+          NOT_A_KEBAB:
+            subscribe:
+              message:
+                messageId: Message1
+        `,
+      'asyncapi.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ 'channels-kebab-case': 'error' }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/channels/NOT_A_KEBAB",
+              "reportOnKey": true,
+              "source": "asyncapi.yaml",
+            },
+          ],
+          "message": "\`NOT_A_KEBAB\` does not use kebab-case.",
+          "ruleId": "channels-kebab-case",
+          "severity": "error",
+          "suggest": Array [],
+        },
+      ]
+    `);
+  });
+
+  it('should report on snake_case in channel path', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+        asyncapi: '2.6.0'
+        info:
+          title: Cool API
+          version: 1.0.0
+        channels:
+          snake_kebab:
+            subscribe:
+              message:
+                messageId: Message1
+        `,
+      'asyncapi.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ 'channels-kebab-case': 'error' }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/channels/snake_kebab",
+              "reportOnKey": true,
+              "source": "asyncapi.yaml",
+            },
+          ],
+          "message": "\`snake_kebab\` does not use kebab-case.",
+          "ruleId": "channels-kebab-case",
+          "severity": "error",
+          "suggest": Array [],
+        },
+      ]
+    `);
+  });
+
+  it('should allow trailing slash in channel path with "channels-kebab-case" rule', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+        asyncapi: '2.6.0'
+        info:
+          title: Cool API
+          version: 1.0.0
+        channels:
+          kebab/:
+            subscribe:
+              message:
+                messageId: Message1
+        `,
+      'asyncapi.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({
+        'paths-kebab-case': 'error',
+        'no-path-trailing-slash': 'off',
+      }),
+    });
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`Array []`);
+  });
+
+  it('words with hyphens are allowed with "channels-kebab-case" rule', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+        asyncapi: '2.6.0'
+        info:
+          title: Cool API
+          version: 1.0.0
+        channels:
+          kebab-with-longer-channel-path:
+            subscribe:
+              message:
+                messageId: Message1
+        `,
+      'asyncapi.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({
+        'paths-kebab-case': 'error',
+      }),
+    });
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`Array []`);
+  });
+});