@redocly/openapi-core 1.0.0-beta.94 → 1.0.0-beta.95

package/src/config/types.ts

@@ -0,0 +1,168 @@
+import type { ProblemSeverity } from '../walk';
+import type {
+  Oas3PreprocessorsSet,
+  OasMajorVersion,
+  Oas3DecoratorsSet,
+  Oas2RuleSet,
+  Oas2PreprocessorsSet,
+  Oas2DecoratorsSet,
+  Oas3RuleSet,
+  OasVersion,
+} from '../oas-types';
+import type { NodeType } from '../types';
+
+export type RuleConfig =
+  | ProblemSeverity
+  | 'off'
+  | ({
+      severity?: ProblemSeverity;
+    } & Record<string, any>);
+
+export type PreprocessorConfig =
+  | ProblemSeverity
+  | 'off'
+  | 'on'
+  | ({
+      severity?: ProblemSeverity;
+    } & Record<string, any>);
+
+export type DecoratorConfig = PreprocessorConfig;
+
+export type LintRawConfig = {
+  plugins?: (string | Plugin)[];
+  extends?: string[];
+  doNotResolveExamples?: boolean;
+  recommendedFallback?: boolean;
+
+  rules?: Record<string, RuleConfig>;
+  oas2Rules?: Record<string, RuleConfig>;
+  oas3_0Rules?: Record<string, RuleConfig>;
+  oas3_1Rules?: Record<string, RuleConfig>;
+
+  preprocessors?: Record<string, PreprocessorConfig>;
+  oas2Preprocessors?: Record<string, PreprocessorConfig>;
+  oas3_0Preprocessors?: Record<string, PreprocessorConfig>;
+  oas3_1Preprocessors?: Record<string, PreprocessorConfig>;
+
+  decorators?: Record<string, DecoratorConfig>;
+  oas2Decorators?: Record<string, DecoratorConfig>;
+  oas3_0Decorators?: Record<string, DecoratorConfig>;
+  oas3_1Decorators?: Record<string, DecoratorConfig>;
+};
+
+export type ResolvedLintConfig = PluginLintConfig & {
+  plugins?: Plugin[];
+  recommendedFallback?: boolean;
+  extends?: void | never;
+  extendPaths?: string[];
+  pluginPaths?: string[];
+};
+
+export type PreprocessorsConfig = {
+  oas3?: Oas3PreprocessorsSet;
+  oas2?: Oas2PreprocessorsSet;
+};
+
+export type DecoratorsConfig = {
+  oas3?: Oas3DecoratorsSet;
+  oas2?: Oas2DecoratorsSet;
+};
+
+export type TypesExtensionFn = (
+  types: Record<string, NodeType>,
+  oasVersion: OasVersion,
+) => Record<string, NodeType>;
+
+export type TypeExtensionsConfig = Partial<Record<OasMajorVersion, TypesExtensionFn>>;
+
+export type CustomRulesConfig = {
+  oas3?: Oas3RuleSet;
+  oas2?: Oas2RuleSet;
+};
+
+export type Plugin = {
+  id: string;
+  configs?: Record<string, PluginLintConfig>;
+  rules?: CustomRulesConfig;
+  preprocessors?: PreprocessorsConfig;
+  decorators?: DecoratorsConfig;
+  typeExtension?: TypeExtensionsConfig;
+};
+
+export type PluginLintConfig = Omit<LintRawConfig, 'plugins' | 'extends'>;
+
+export type ResolveHeader =
+  | {
+      name: string;
+      envVariable?: undefined;
+      value: string;
+      matches: string;
+    }
+  | {
+      name: string;
+      value?: undefined;
+      envVariable: string;
+      matches: string;
+    };
+
+export type RawResolveConfig = {
+  http?: Partial<HttpResolveConfig>;
+};
+
+export type HttpResolveConfig = {
+  headers: ResolveHeader[];
+  customFetch?: Function;
+};
+
+export type ResolveConfig = {
+  http: HttpResolveConfig;
+};
+
+export type Region = 'us' | 'eu';
+
+export type AccessTokens = { [region in Region]?: string };
+
+export type DeprecatedRawConfig = {
+  apiDefinitions?: Record<string, string>;
+  lint?: LintRawConfig;
+  resolve?: RawResolveConfig;
+  region?: Region;
+  referenceDocs?: Record<string, any>;
+};
+
+export type Api = {
+  root: string;
+  lint?: Omit<LintRawConfig, 'plugins'>;
+  'features.openapi'?: Record<string, any>;
+  'features.mockServer'?: Record<string, any>;
+};
+export type ResolvedApi = Omit<Api, 'lint'> & { lint: Omit<ResolvedLintConfig, 'plugins'>};
+
+export type RawConfig = {
+  apis?: Record<string, Api>;
+  lint?: LintRawConfig;
+  resolve?: RawResolveConfig;
+  region?: Region;
+  'features.openapi'?: Record<string, any>;
+  'features.mockServer'?: Record<string, any>;
+  organization?: string;
+};
+
+export type ResolvedConfig = Omit<RawConfig, 'lint' | 'apis'> & {
+  lint: ResolvedLintConfig;
+  apis: Record<string,ResolvedApi>
+};
+
+export type RulesFields =
+  | 'rules'
+  | 'oas2Rules'
+  | 'oas3_0Rules'
+  | 'oas3_1Rules'
+  | 'preprocessors'
+  | 'oas2Preprocessors'
+  | 'oas3_0Preprocessors'
+  | 'oas3_1Preprocessors'
+  | 'decorators'
+  | 'oas2Decorators'
+  | 'oas3_0Decorators'
+  | 'oas3_1Decorators';

package/src/config/utils.ts

@@ -0,0 +1,208 @@
+import { green, yellow } from 'colorette';
+import { assignExisting } from '../utils';
+import { Config } from './config';
+
+import type {
+  Api,
+  DeprecatedRawConfig,
+  Plugin,
+  RawConfig,
+  RawResolveConfig,
+  ResolveConfig,
+  ResolvedLintConfig,
+  RulesFields,
+} from './types';
+
+export function parsePresetName(presetName: string): { pluginId: string; configName: string } {
+  if (presetName.indexOf('/') > -1) {
+    const [pluginId, configName] = presetName.split('/');
+    return { pluginId, configName };
+  } else {
+    return { pluginId: '', configName: presetName };
+  }
+}
+
+export function transformApiDefinitionsToApis(
+  apiDefinitions: Record<string, string> = {},
+): Record<string, Api> {
+  let apis: Record<string, Api> = {};
+  for (const [apiName, apiPath] of Object.entries(apiDefinitions)) {
+    apis[apiName] = { root: apiPath };
+  }
+  return apis;
+}
+
+export function prefixRules<T extends Record<string, any>>(rules: T, prefix: string) {
+  if (!prefix) return rules;
+
+  const res: any = {};
+  for (const name of Object.keys(rules)) {
+    res[`${prefix}/${name}`] = rules[name];
+  }
+
+  return res;
+}
+
+export function mergeExtends(rulesConfList: ResolvedLintConfig[]) {
+  const result: Omit<ResolvedLintConfig, RulesFields> &
+    Required<Pick<ResolvedLintConfig, RulesFields>> = {
+    rules: {},
+    oas2Rules: {},
+    oas3_0Rules: {},
+    oas3_1Rules: {},
+
+    preprocessors: {},
+    oas2Preprocessors: {},
+    oas3_0Preprocessors: {},
+    oas3_1Preprocessors: {},
+
+    decorators: {},
+    oas2Decorators: {},
+    oas3_0Decorators: {},
+    oas3_1Decorators: {},
+
+    plugins: [],
+    pluginPaths: [],
+    extendPaths: [],
+  };
+
+  for (let rulesConf of rulesConfList) {
+    if (rulesConf.extends) {
+      throw new Error(
+        `\`extends\` is not supported in shared configs yet: ${JSON.stringify(
+          rulesConf,
+          null,
+          2,
+        )}.`,
+      );
+    }
+
+    Object.assign(result.rules, rulesConf.rules);
+    Object.assign(result.oas2Rules, rulesConf.oas2Rules);
+    assignExisting(result.oas2Rules, rulesConf.rules || {});
+    Object.assign(result.oas3_0Rules, rulesConf.oas3_0Rules);
+    assignExisting(result.oas3_0Rules, rulesConf.rules || {});
+    Object.assign(result.oas3_1Rules, rulesConf.oas3_1Rules);
+    assignExisting(result.oas3_1Rules, rulesConf.rules || {});
+
+    Object.assign(result.preprocessors, rulesConf.preprocessors);
+    Object.assign(result.oas2Preprocessors, rulesConf.oas2Preprocessors);
+    assignExisting(result.oas2Preprocessors, rulesConf.preprocessors || {});
+    Object.assign(result.oas3_0Preprocessors, rulesConf.oas3_0Preprocessors);
+    assignExisting(result.oas3_0Preprocessors, rulesConf.preprocessors || {});
+    Object.assign(result.oas3_1Preprocessors, rulesConf.oas3_1Preprocessors);
+    assignExisting(result.oas3_1Preprocessors, rulesConf.preprocessors || {});
+
+    Object.assign(result.decorators, rulesConf.decorators);
+    Object.assign(result.oas2Decorators, rulesConf.oas2Decorators);
+    assignExisting(result.oas2Decorators, rulesConf.decorators || {});
+    Object.assign(result.oas3_0Decorators, rulesConf.oas3_0Decorators);
+    assignExisting(result.oas3_0Decorators, rulesConf.decorators || {});
+    Object.assign(result.oas3_1Decorators, rulesConf.oas3_1Decorators);
+    assignExisting(result.oas3_1Decorators, rulesConf.decorators || {});
+
+    result.plugins!.push(...(rulesConf.plugins || []));
+    result.pluginPaths!.push(...(rulesConf.pluginPaths || []));
+    result.extendPaths!.push(...new Set(rulesConf.extendPaths));
+  }
+
+  return result;
+}
+
+export function getMergedConfig(config: Config, entrypointAlias?: string): Config {
+  const extendPaths = [
+    ...Object.values(config.apis).map((api) => api?.lint?.extendPaths),
+    config.rawConfig?.lint?.extendPaths,
+  ]
+    .flat()
+    .filter(Boolean) as string[];
+
+  const pluginPaths = [
+    ...Object.values(config.apis).map((api) => api?.lint?.pluginPaths),
+    config.rawConfig?.lint?.pluginPaths,
+  ]
+    .flat()
+    .filter(Boolean) as string[];
+
+  return entrypointAlias
+    ? new Config(
+        {
+          ...config.rawConfig,
+          lint: {
+            ...(config.apis[entrypointAlias]
+              ? config.apis[entrypointAlias].lint
+              : config.rawConfig.lint),
+            extendPaths,
+            pluginPaths,
+          },
+          'features.openapi': {
+            ...config['features.openapi'],
+            ...config.apis[entrypointAlias]?.['features.openapi'],
+          },
+          'features.mockServer': {
+            ...config['features.mockServer'],
+            ...config.apis[entrypointAlias]?.['features.mockServer'],
+          },
+          // TODO: merge everything else here
+        },
+        config.configFile,
+      )
+    : config;
+}
+
+export function transformConfig(rawConfig: DeprecatedRawConfig | RawConfig): RawConfig {
+  if ((rawConfig as RawConfig).apis && (rawConfig as DeprecatedRawConfig).apiDefinitions) {
+    throw new Error("Do not use 'apiDefinitions' field. Use 'apis' instead.\n");
+  }
+  if (
+    (rawConfig as RawConfig)['features.openapi'] &&
+    (rawConfig as DeprecatedRawConfig).referenceDocs
+  ) {
+    throw new Error("Do not use 'referenceDocs' field. Use 'features.openapi' instead.\n");
+  }
+  const { apiDefinitions, referenceDocs, ...rest } = rawConfig as DeprecatedRawConfig & RawConfig;
+  if (apiDefinitions) {
+    process.stderr.write(
+      `The ${yellow('apiDefinitions')} field is deprecated. Use ${green(
+        'apis',
+      )} instead. Read more about this change: https://redocly.com/docs/api-registry/guides/migration-guide-config-file/#changed-properties\n`,
+    );
+  }
+  if (referenceDocs) {
+    process.stderr.write(
+      `The ${yellow('referenceDocs')} field is deprecated. Use ${green(
+        'features.openapi',
+      )} instead. Read more about this change: https://redocly.com/docs/api-registry/guides/migration-guide-config-file/#changed-properties\n`,
+    );
+  }
+  return {
+    'features.openapi': referenceDocs,
+    apis: transformApiDefinitionsToApis(apiDefinitions),
+    ...rest,
+  };
+}
+
+export function getResolveConfig(resolve?: RawResolveConfig): ResolveConfig {
+  return {
+    http: {
+      headers: resolve?.http?.headers ?? [],
+      customFetch: undefined,
+    },
+  };
+}
+
+export function getUniquePlugins(plugins: Plugin[]): Plugin[] {
+  const seen = new Set();
+  const results = [];
+  for (const p of plugins) {
+    if (!seen.has(p.id)) {
+      results.push(p);
+      seen.add(p.id);
+    } else if (p.id) {
+      process.stderr.write(
+        `Duplicate plugin id "${yellow(p.id)}".\n`,
+      );
+    }
+  }
+  return results;
+}

package/src/decorators/__tests__/remove-x-internal.test.ts

@@ -25,7 +25,7 @@ describe('oas3 remove-x-internal', () => {
     const { bundle: res } = await bundleDocument({
       document: testDocument,
       externalRefResolver: new BaseResolver(),
-      config: makeConfig({}, { 'remove-x-internal': { internalFlagProperty: 'removeit' } }),
+      config: await makeConfig({}, { 'remove-x-internal': { internalFlagProperty: 'removeit' } }),
     });
     expect(res.parsed).toMatchInlineSnapshot(`
           openapi: 3.0.0
@@ -92,7 +92,7 @@ describe('oas3 remove-x-internal', () => {
     const { bundle: res } = await bundleDocument({
       document: testDoc,
       externalRefResolver: new BaseResolver(),
-      config: makeConfig({}, { 'remove-x-internal': 'on' }),
+      config: await makeConfig({}, { 'remove-x-internal': 'on' }),
     });
     expect(res.parsed).toMatchInlineSnapshot(`
       openapi: 3.1.0
@@ -165,7 +165,7 @@ describe('oas3 remove-x-internal', () => {
     const { bundle: res } = await bundleDocument({
       document: testDoc,
       externalRefResolver: new BaseResolver(),
-      config: makeConfig({}, { 'remove-x-internal': 'on' }),
+      config: await makeConfig({}, { 'remove-x-internal': 'on' }),
     });
 
     expect(res.parsed).toMatchInlineSnapshot(`
@@ -239,7 +239,7 @@ describe('oas3 remove-x-internal', () => {
     const { bundle: res } = await bundleDocument({
       document: testDoc,
       externalRefResolver: new BaseResolver(),
-      config: makeConfig({}, { 'remove-x-internal': 'on' }),
+      config: await makeConfig({}, { 'remove-x-internal': 'on' }),
     });
     expect(res.parsed).toMatchInlineSnapshot(`
       openapi: 3.0.1
@@ -302,7 +302,7 @@ describe('oas2 remove-x-internal', () => {
     const { bundle: res } = await bundleDocument({
       document: testDoc,
       externalRefResolver: new BaseResolver(),
-      config: makeConfig({}, { 'remove-x-internal': 'on' }),
+      config: await makeConfig({}, { 'remove-x-internal': 'on' }),
     });
     expect(res.parsed).toMatchInlineSnapshot(`
           swagger: '2.0'

package/src/format/format.ts

@@ -16,10 +16,10 @@ import { NormalizedProblem, ProblemSeverity, LineColLocationObject, LocationObje
 import { getCodeframe, getLineColLocation } from './codeframes';
 
 export type Totals = {
-	errors: number;
-	warnings: number;
-	ignored: number;
-}
+  errors: number;
+  warnings: number;
+  ignored: number;
+};
 
 const ERROR_MESSAGE = {
   INVALID_SEVERITY_LEVEL: 'Invalid severity level; accepted values: error or warn',
@@ -40,13 +40,18 @@ const SEVERITY_NAMES = {
   error: 'Error',
 };
 
+const CODECLIMATE_SEVERITY_MAPPING = {
+  error: 'critical',
+  warn: 'minor',
+};
+
 const MAX_SUGGEST = 5;
 
 function severityToNumber(severity: ProblemSeverity) {
   return severity === 'error' ? 1 : 2;
 }
 
-export type OutputFormat = 'codeframe' | 'stylish' | 'json' | 'checkstyle';
+export type OutputFormat = 'codeframe' | 'stylish' | 'json' | 'checkstyle' | 'codeclimate';
 
 export function getTotals(problems: (NormalizedProblem & { ignored?: boolean })[]): Totals {
   let errors = 0;
@@ -76,7 +81,7 @@ export function formatProblems(
     cwd?: string;
     format?: OutputFormat;
     color?: boolean;
-    totals: Totals
+    totals: Totals;
     version: string;
   },
 ) {
@@ -142,6 +147,9 @@ export function formatProblems(
       process.stdout.write(`</checkstyle>\n`);
       break;
     }
+    case 'codeclimate':
+      outputForCodeClimate();
+      break;
   }
 
   if (totalProblems - ignoredProblems > maxProblems) {
@@ -152,6 +160,25 @@ export function formatProblems(
     );
   }
 
+  function outputForCodeClimate() {
+    const issues = problems.map((p) => {
+      const location = p.location[0]; // TODO: support multiple location
+      const lineCol = getLineColLocation(location);
+      return {
+        description: p.message,
+        location: {
+          path: path.relative(cwd, location.source.absoluteRef),
+          lines: {
+            begin: lineCol.start.line,
+          },
+        },
+        severity: CODECLIMATE_SEVERITY_MAPPING[p.severity],
+        fingerprint: `${p.ruleId}${p.location.length > 0 ? '-' + p.location[0].pointer : ''}`,
+      };
+    });
+    process.stdout.write(JSON.stringify(issues, null, 2));
+  }
+
   function outputJSON() {
     const resultObject = {
       totals,
@@ -214,6 +241,9 @@ export function formatProblems(
 
   function formatStylish(problem: OnlyLineColProblem, locationPad: number, ruleIdPad: number) {
     const color = COLORS[problem.severity];
+    if (!SEVERITY_NAMES[problem.severity]) {
+      return 'Error not found severity. Please check your config file. Allowed values: \`warn,error,off\`'
+    }
     const severityName = color(SEVERITY_NAMES[problem.severity].toLowerCase().padEnd(7));
     const { start } = problem.location[0];
     return `  ${`${start.line}:${start.col}`.padEnd(

package/src/index.ts

@@ -29,9 +29,13 @@ export {
   Region,
   getMergedConfig,
   transformConfig,
-} from './config/config';
+  loadConfig,
+  getConfig,
+  findConfig,
+  CONFIG_FILE_NAMES,
+} from './config';
+
 
-export { loadConfig, getConfig, findConfig, CONFIG_FILE_NAMES } from './config/load';
 export { RedoclyClient, isRedoclyRegistryURL } from './redocly';
 
 export {

package/src/lint.ts

@@ -7,14 +7,13 @@ import { Oas3Types } from './types/oas3';
 import { Oas2Types } from './types/oas2';
 import { NodeType } from './types';
 import { ProblemSeverity, WalkContext, walkDocument } from './walk';
-import { LintConfig, Config } from './config/config';
+import { LintConfig, Config, initRules, defaultPlugin, resolvePlugins } from './config';
 import { normalizeTypes } from './types';
-import { initRules } from './config/rules';
 import { releaseAjvInstance } from './rules/ajv';
 import { detectOpenAPI, Oas3RuleSet, OasMajorVersion, OasVersion, openAPIMajor } from './oas-types';
 import { ConfigTypes } from './types/redocly-yaml';
 import { OasSpec } from './rules/common/spec';
-import { defaultPlugin } from './config/builtIn';
+
 
 export async function lint(opts: {
   ref: string;
@@ -104,9 +103,9 @@ export async function lintConfig(opts: {
     oasVersion: OasVersion.Version3_0,
     visitorsData: {},
   };
+  const plugins = resolvePlugins([defaultPlugin]);
   const config = new LintConfig({
-    plugins: [defaultPlugin],
-    extends: [],
+    plugins,
     rules: { spec: 'error' },
   });
 

package/src/redocly/__tests__/redocly-client.test.ts

@@ -1,5 +1,12 @@
 import { RedoclyClient } from '../index';
 
+jest.mock('node-fetch', () => ({
+  default: jest.fn(() => ({
+    ok: true,
+    json: jest.fn().mockResolvedValue({}),
+  })),
+}));
+
 describe('RedoclyClient', () => {
   const REDOCLY_DOMAIN_US = 'redocly.com';
   const REDOCLY_DOMAIN_EU = 'eu.redocly.com';

package/src/redocly/index.ts

@@ -3,10 +3,12 @@ import { resolve } from 'path';
 import { homedir } from 'os';
 import { red, green, gray, yellow } from 'colorette';
 import { RegistryApi } from './registry-api';
-import { AccessTokens, DEFAULT_REGION, DOMAINS, Region, AVAILABLE_REGIONS } from '../config/config';
+import { DEFAULT_REGION, DOMAINS, AVAILABLE_REGIONS } from '../config/config';
 import { RegionalToken, RegionalTokenWithValidity } from './redocly-client-types';
 import { isNotEmptyObject } from '../utils';
 
+import type { AccessTokens, Region } from '../config/types';
+
 const TOKEN_FILENAME = '.redocly-config.json';
 
 let REDOCLY_DOMAIN: string; // workaround for the isRedoclyRegistryURL, see more below

package/src/redocly/redocly-client-types.ts

@@ -1,4 +1,4 @@
-import { Region } from '../config/config';
+import type { Region } from '../config/types';
 
 export interface RegionalToken {
   region: Region;

package/src/redocly/registry-api.ts

@@ -1,9 +1,11 @@
 import fetch, { RequestInit, HeadersInit } from 'node-fetch';
 import { RegistryApiTypes } from './registry-api-types';
-import { AccessTokens, Region, DEFAULT_REGION, DOMAINS } from '../config/config';
+import { DEFAULT_REGION, DOMAINS } from '../config/config';
 import { isNotEmptyObject } from '../utils';
 const version = require('../../package.json').version;
 
+import type { AccessTokens, Region } from '../config/types';
+
 export class RegistryApi {
   constructor(private accessTokens: AccessTokens, private region: Region) {}
 

package/src/resolve.ts

@@ -1,13 +1,11 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import * as url from 'url';
-
 import { OasRef } from './typings/openapi';
 import { isRef, joinPointer, escapePointer, parseRef, isAbsoluteUrl } from './ref-utils';
 import type { YAMLNode, LoadOptions } from 'yaml-ast-parser';
 import { NormalizedNodeType, isNamedType } from './types';
 import { readFileFromUrl, parseYaml } from './utils';
-import { ResolveConfig } from './config/config';
+import { ResolveConfig } from './config/types';
 
 export type CollectedRefs = Map<string /* absoluteFilePath */, Document>;
 
@@ -105,7 +103,7 @@ export class BaseResolver {
     }
 
     if (base && isAbsoluteUrl(base)) {
-      return url.resolve(base, ref);
+      return new URL(ref, base).href;
     }
 
     return path.resolve(base ? path.dirname(base) : process.cwd(), ref);

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

@@ -21,7 +21,7 @@ describe('oas3 boolean-parameter-prefixes', () => {
     const results = await lintDocument({
       externalRefResolver: new BaseResolver(),
       document,
-      config: makeConfig({
+      config: await makeConfig({
         'no-unresolved-refs': 'error',
       }),
     });
@@ -61,7 +61,7 @@ describe('oas3 boolean-parameter-prefixes', () => {
     const results = await lintDocument({
       externalRefResolver: new BaseResolver(),
       document,
-      config: makeConfig({
+      config: await makeConfig({
         'no-unresolved-refs': 'error',
       }),
     });
@@ -118,7 +118,7 @@ describe('oas3 boolean-parameter-prefixes', () => {
     const results = await lintDocument({
       externalRefResolver: new BaseResolver(),
       document,
-      config: makeConfig({
+      config: await makeConfig({
         'no-unresolved-refs': 'error',
       }),
     });
@@ -142,7 +142,7 @@ describe('oas3 boolean-parameter-prefixes', () => {
     const results = await lintDocument({
       externalRefResolver: new BaseResolver(),
       document,
-      config: makeConfig({
+      config: await makeConfig({
         'no-unresolved-refs': 'error',
       }),
     });

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

@@ -17,7 +17,7 @@ describe('Oas3 info-description', () => {
     const results = await lintDocument({
       externalRefResolver: new BaseResolver(),
       document,
-      config: makeConfig({
+      config: await makeConfig({
         'info-description': 'error',
       }),
     });
@@ -55,7 +55,7 @@ describe('Oas3 info-description', () => {
     const results = await lintDocument({
       externalRefResolver: new BaseResolver(),
       document,
-      config: makeConfig({
+      config: await makeConfig({
         'info-description': 'error',
       }),
     });
@@ -92,7 +92,7 @@ describe('Oas3 info-description', () => {
     const results = await lintDocument({
       externalRefResolver: new BaseResolver(),
       document,
-      config: makeConfig({
+      config: await makeConfig({
         'info-description': 'error',
       }),
     });