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

package/lib/utils.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNotEmptyObject = exports.slash = exports.isPathParameter = exports.readFileAsStringSync = exports.isSingular = exports.validateMimeTypeOAS3 = exports.validateMimeType = exports.splitCamelCaseIntoWords = exports.omitObjectProps = exports.pickObjectProps = exports.match = exports.readFileFromUrl = exports.isEmptyArray = exports.isEmptyObject = exports.isPlainObject = exports.notUndefined = exports.loadYaml = exports.popStack = exports.pushStack = exports.stringifyYaml = exports.parseYaml = void 0;
+exports.assignExisting = exports.isNotString = exports.isString = exports.isNotEmptyObject = exports.slash = exports.isPathParameter = exports.readFileAsStringSync = exports.isSingular = exports.validateMimeTypeOAS3 = exports.validateMimeType = exports.splitCamelCaseIntoWords = exports.omitObjectProps = exports.pickObjectProps = exports.match = exports.readFileFromUrl = exports.isEmptyArray = exports.isEmptyObject = exports.isPlainObject = exports.notUndefined = exports.loadYaml = exports.popStack = exports.pushStack = exports.stringifyYaml = exports.parseYaml = void 0;
 const fs = require("fs");
 const minimatch = require("minimatch");
 const node_fetch_1 = require("node-fetch");
@@ -156,3 +156,20 @@ function isNotEmptyObject(obj) {
     return !!obj && Object.keys(obj).length > 0;
 }
 exports.isNotEmptyObject = isNotEmptyObject;
+// TODO: use it everywhere
+function isString(value) {
+    return typeof value === 'string';
+}
+exports.isString = isString;
+function isNotString(value) {
+    return !isString(value);
+}
+exports.isNotString = isNotString;
+function assignExisting(target, obj) {
+    for (let k of Object.keys(obj)) {
+        if (target.hasOwnProperty(k)) {
+            target[k] = obj[k];
+        }
+    }
+}
+exports.assignExisting = assignExisting;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redocly/openapi-core",
-  "version": "1.0.0-beta.92",
+  "version": "1.0.0-beta.95",
   "description": "",
   "main": "lib/index.js",
   "engines": {
@@ -13,7 +13,10 @@
     "url": "https://github.com/Redocly/openapi-cli.git"
   },
   "browser": {
-    "fs": false
+    "fs": false,
+    "path": "path-browserify",
+    "os": false,
+    "node-fetch": false
   },
   "homepage": "https://github.com/Redocly/openapi-cli",
   "keywords": [

package/src/__tests__/lint.test.ts

@@ -174,7 +174,7 @@ describe('lint', () => {
     const results = await lintDocument({
       externalRefResolver: new BaseResolver(),
       document,
-      config: makeConfig({ spec: 'error' }),
+      config: await makeConfig({ spec: 'error' }),
     });
 
     expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`Array []`);

package/src/benchmark/benches/recommended-oas3.bench.ts

@@ -1,10 +1,9 @@
 import { readFileSync } from 'fs';
 import { join as pathJoin, resolve as pathResolve } from 'path';
 import { lintDocument } from '../../lint';
-import { LintConfig } from '../../config/config';
+import { LintConfig, defaultPlugin, resolvePreset } from '../../config';
 import { BaseResolver } from '../../resolve';
 import { parseYamlToDocument } from '../utils';
-import { defaultPlugin } from '../../config/builtIn';
 
 export const name = 'Validate with recommended rules';
 export const count = 10;
@@ -18,6 +17,6 @@ export function measureAsync() {
   return lintDocument({
     externalRefResolver: new BaseResolver(),
     document: rebillyDocument,
-    config: new LintConfig({ plugins: [defaultPlugin] }),
+    config: new LintConfig(resolvePreset('recommended', [defaultPlugin])),
   });
 }

package/src/benchmark/utils.ts

@@ -1,7 +1,9 @@
 import { parseYaml } from '../js-yaml';
 import { Document, Source } from '../resolve';
 import { Oas3RuleSet } from '../oas-types';
-import { RuleConfig, LintConfig, Plugin } from '../config/config';
+import { LintConfig, mergeExtends, resolvePlugins } from '../config';
+
+import type { RuleConfig, Plugin, ResolvedLintConfig } from '../config/types';
 
 export function parseYamlToDocument(body: string, absoluteRef: string = ''): Document {
   return {
@@ -16,16 +18,19 @@ export function makeConfigForRuleset(rules: Oas3RuleSet, plugin?: Partial<Plugin
   Object.keys(rules).forEach((name) => {
     rulesConf[`${ruleId}/${name}`] = 'error';
   });
-
-  return new LintConfig({
-    plugins: [
+  const extendConfigs = [
+    resolvePlugins([
       {
         ...plugin,
         id: ruleId,
         rules: { oas3: rules },
       },
-    ],
-    extends: [],
-    rules: rulesConf,
-  });
+    ]) as ResolvedLintConfig,
+  ];
+  if (rules) {
+    extendConfigs.push({ rules });
+  }
+  const lint = mergeExtends(extendConfigs);
+
+  return new LintConfig(lint);
 }

package/src/bundle.ts

@@ -8,7 +8,6 @@ import { NormalizedNodeType, normalizeTypes, NodeType } from './types';
 import { WalkContext, walkDocument, UserContext, ResolveResult } from './walk';
 import { detectOpenAPI, openAPIMajor, OasMajorVersion } from './oas-types';
 import { isRef, Location, refBaseName } from './ref-utils';
-import type { Config, LintConfig } from './config/config';
 import { initRules } from './config/rules';
 import { reportUnresolvedRef } from './rules/no-unresolved-refs';
 import { isPlainObject } from './utils';
@@ -17,6 +16,8 @@ import { isRedoclyRegistryURL } from './redocly';
 import { RemoveUnusedComponents as RemoveUnusedComponentsOas2 } from './rules/oas2/remove-unused-components';
 import { RemoveUnusedComponents as RemoveUnusedComponentsOas3 } from './rules/oas3/remove-unused-components';
 
+import type { Config, LintConfig } from './config';
+
 export type Oas3RuleSet = Record<string, Oas3Rule>;
 
 export enum OasVersion {

package/src/config/__tests__/__snapshots__/config-resolvers.test.ts.snap

@@ -0,0 +1,140 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`resolveConfig should ignore minimal from the root and read local file 1`] = `
+Object {
+  "decorators": Object {},
+  "doNotResolveExamples": undefined,
+  "oas2Decorators": Object {},
+  "oas2Preprocessors": Object {},
+  "oas2Rules": Object {},
+  "oas3_0Decorators": Object {},
+  "oas3_0Preprocessors": Object {},
+  "oas3_0Rules": Object {
+    "no-empty-servers": "error",
+    "no-example-value-and-externalValue": "error",
+    "no-invalid-media-type-examples": "error",
+    "no-server-example.com": "warn",
+    "no-server-trailing-slash": "error",
+    "no-servers-empty-enum": "error",
+    "no-undefined-server-variable": "error",
+    "no-unused-components": "warn",
+  },
+  "oas3_1Decorators": Object {},
+  "oas3_1Preprocessors": Object {},
+  "oas3_1Rules": Object {
+    "no-empty-servers": "error",
+    "no-example-value-and-externalValue": "error",
+    "no-server-example.com": "warn",
+    "no-server-trailing-slash": "error",
+    "no-servers-empty-enum": "error",
+    "no-undefined-server-variable": "error",
+    "no-unused-components": "warn",
+  },
+  "preprocessors": Object {},
+  "recommendedFallback": false,
+  "rules": Object {
+    "assertions": "warn",
+    "boolean-parameter-prefixes": "error",
+    "info-contact": "off",
+    "info-description": "warn",
+    "info-license": "warn",
+    "info-license-url": "warn",
+    "local/operation-id-not-test": "error",
+    "no-ambiguous-paths": "warn",
+    "no-enum-type-mismatch": "error",
+    "no-identical-paths": "error",
+    "no-invalid-media-type-examples": "error",
+    "no-path-trailing-slash": "error",
+    "no-unresolved-refs": "error",
+    "operation-2xx-response": "warn",
+    "operation-4xx-response": "error",
+    "operation-description": "error",
+    "operation-operationId": "warn",
+    "operation-operationId-unique": "error",
+    "operation-operationId-url-safe": "error",
+    "operation-parameters-unique": "error",
+    "operation-security-defined": "error",
+    "operation-singular-tag": "off",
+    "operation-summary": "error",
+    "operation-tag-defined": "off",
+    "parameter-description": "off",
+    "path-declaration-must-exist": "error",
+    "path-http-verbs-order": "error",
+    "path-not-include-query": "error",
+    "path-parameters-defined": "error",
+    "paths-kebab-case": "off",
+    "spec": "error",
+    "tag-description": "warn",
+    "tags-alphabetical": "off",
+  },
+}
+`;
+
+exports[`resolveLint should resolve extends with local file config witch contains path to nested config 1`] = `
+Object {
+  "decorators": Object {},
+  "doNotResolveExamples": undefined,
+  "oas2Decorators": Object {},
+  "oas2Preprocessors": Object {},
+  "oas2Rules": Object {},
+  "oas3_0Decorators": Object {},
+  "oas3_0Preprocessors": Object {},
+  "oas3_0Rules": Object {
+    "no-empty-servers": "error",
+    "no-example-value-and-externalValue": "error",
+    "no-invalid-media-type-examples": "warn",
+    "no-server-example.com": "warn",
+    "no-server-trailing-slash": "error",
+    "no-servers-empty-enum": "error",
+    "no-undefined-server-variable": "error",
+    "no-unused-components": "warn",
+  },
+  "oas3_1Decorators": Object {},
+  "oas3_1Preprocessors": Object {},
+  "oas3_1Rules": Object {
+    "no-empty-servers": "error",
+    "no-example-value-and-externalValue": "error",
+    "no-server-example.com": "warn",
+    "no-server-trailing-slash": "error",
+    "no-servers-empty-enum": "error",
+    "no-undefined-server-variable": "error",
+    "no-unused-components": "warn",
+  },
+  "preprocessors": Object {},
+  "recommendedFallback": undefined,
+  "rules": Object {
+    "assertions": "warn",
+    "boolean-parameter-prefixes": "error",
+    "info-contact": "off",
+    "info-description": "warn",
+    "info-license": "warn",
+    "info-license-url": "warn",
+    "local/operation-id-not-test": "error",
+    "no-ambiguous-paths": "warn",
+    "no-enum-type-mismatch": "error",
+    "no-identical-paths": "error",
+    "no-invalid-media-type-examples": "warn",
+    "no-path-trailing-slash": "error",
+    "no-unresolved-refs": "error",
+    "operation-2xx-response": "error",
+    "operation-4xx-response": "off",
+    "operation-description": "off",
+    "operation-operationId": "warn",
+    "operation-operationId-unique": "error",
+    "operation-operationId-url-safe": "error",
+    "operation-parameters-unique": "error",
+    "operation-security-defined": "error",
+    "operation-singular-tag": "off",
+    "operation-summary": "error",
+    "operation-tag-defined": "off",
+    "parameter-description": "off",
+    "path-declaration-must-exist": "error",
+    "path-not-include-query": "error",
+    "path-parameters-defined": "error",
+    "paths-kebab-case": "off",
+    "spec": "error",
+    "tag-description": "warn",
+    "tags-alphabetical": "off",
+  },
+}
+`;

package/src/config/__tests__/config-resolvers.test.ts

@@ -0,0 +1,398 @@
+import { resolveLint, resolveApis, resolveConfig } from '../config-resolvers';
+const path = require('path');
+
+import type { LintRawConfig, RawConfig } from '../types';
+
+const configPath = path.join(__dirname, 'fixtures/resolve-config/.redocly.yaml');
+const baseLintConfig: LintRawConfig = {
+  rules: {
+    'operation-2xx-response': 'warn',
+  },
+};
+
+const minimalLintPreset = resolveLint({
+  lintConfig: { ...baseLintConfig, extends: ['minimal'] },
+});
+
+const recommendedLintPreset = resolveLint({
+  lintConfig: { ...baseLintConfig, extends: ['recommended'] },
+});
+
+const removeAbsolutePath = (item: string) =>
+  item.match(/^.*\/packages\/core\/src\/config\/__tests__\/fixtures\/(.*)$/)![1];
+
+describe('resolveLint', () => {
+  it('should return the config with no recommended', async () => {
+    const lint = await resolveLint({ lintConfig: baseLintConfig });
+    expect(lint.plugins?.length).toEqual(1);
+    expect(lint.plugins?.[0].id).toEqual('');
+    expect(lint.rules).toEqual({
+      'operation-2xx-response': 'warn',
+    });
+  });
+
+  it('should return the config with correct order by preset', async () => {
+    expect(
+      await resolveLint({
+        lintConfig: { ...baseLintConfig, extends: ['minimal', 'recommended'] },
+      }),
+    ).toEqual(await recommendedLintPreset);
+    expect(
+      await resolveLint({
+        lintConfig: { ...baseLintConfig, extends: ['recommended', 'minimal'] },
+      }),
+    ).toEqual(await minimalLintPreset);
+  });
+
+  it('should return the same lintConfig when extends is empty array', async () => {
+    const configWithEmptyExtends = await resolveLint({
+      lintConfig: { ...baseLintConfig, extends: [] },
+    });
+    expect(configWithEmptyExtends.plugins?.length).toEqual(1);
+    expect(configWithEmptyExtends.plugins?.[0].id).toEqual('');
+    expect(configWithEmptyExtends.rules).toEqual({
+      'operation-2xx-response': 'warn',
+    });
+  });
+
+  it('should resolve extends with local file config', async () => {
+    const config = {
+      ...baseLintConfig,
+      extends: ['local-config.yaml'],
+    };
+
+    const { plugins, ...lint } = await resolveLint({
+      lintConfig: config,
+      configPath,
+    });
+
+    expect(lint?.rules?.['operation-2xx-response']).toEqual('warn');
+    expect(plugins).toBeDefined();
+    expect(plugins?.length).toBe(2);
+
+    expect(lint.extendPaths!.map(removeAbsolutePath)).toEqual([
+      'resolve-config/.redocly.yaml',
+      'resolve-config/local-config.yaml',
+      'resolve-config/.redocly.yaml',
+    ]);
+    expect(lint.pluginPaths!.map(removeAbsolutePath)).toEqual(['resolve-config/plugin.js']);
+
+    expect(lint.rules).toEqual({
+      'boolean-parameter-prefixes': 'error',
+      'local/operation-id-not-test': 'error',
+      'no-invalid-media-type-examples': 'error',
+      'operation-2xx-response': 'warn',
+      'operation-description': 'error',
+      'path-http-verbs-order': 'error',
+    });
+  });
+
+  // TODO: fix circular test
+  it.skip('should throw circular error', () => {
+    const config = {
+      ...baseLintConfig,
+      extends: ['local-config-with-circular.yaml'],
+    };
+    expect(() => {
+      resolveLint({ lintConfig: config, configPath });
+    }).toThrow('Circular dependency in config file');
+  });
+
+  it('should resolve extends with local file config witch contains path to nested config', async () => {
+    const lintConfig = {
+      extends: ['local-config-with-file.yaml'],
+    };
+    const { plugins, ...lint } = await resolveLint({
+      lintConfig,
+      configPath,
+    });
+
+    expect(lint?.rules?.['no-invalid-media-type-examples']).toEqual('warn');
+    expect(lint?.rules?.['operation-4xx-response']).toEqual('off');
+    expect(lint?.rules?.['operation-2xx-response']).toEqual('error');
+    expect(plugins).toBeDefined();
+    expect(plugins?.length).toBe(3);
+
+    expect(lint.extendPaths!.map(removeAbsolutePath)).toEqual([
+      'resolve-config/.redocly.yaml',
+      'resolve-config/local-config-with-file.yaml',
+      'resolve-config/api/nested-config.yaml',
+      'resolve-config/.redocly.yaml',
+    ]);
+    expect(lint.pluginPaths!.map(removeAbsolutePath)).toEqual([
+      'resolve-config/api/plugin.js',
+      'resolve-config/plugin.js',
+      'resolve-config/api/plugin.js',
+    ]);
+
+    delete lint.extendPaths;
+    delete lint.pluginPaths;
+    expect(lint).toMatchSnapshot();
+  });
+
+  it('should resolve extends with url file config witch contains path to nested config', async () => {
+    const lintConfig = {
+      // This points to ./fixtures/resolve-remote-configs/remote-config.yaml
+      extends: [
+        'https://raw.githubusercontent.com/Redocly/openapi-cli/master/packages/core/src/config/__tests__/fixtures/resolve-remote-configs/remote-config.yaml',
+      ],
+    };
+
+    const { plugins, ...lint } = await resolveLint({
+      lintConfig,
+      configPath,
+    });
+
+    expect(lint?.rules?.['operation-4xx-response']).toEqual('error');
+    expect(lint?.rules?.['operation-2xx-response']).toEqual('error');
+    expect(Object.keys(lint.rules || {}).length).toBe(2);
+
+    expect(lint.extendPaths!.map(removeAbsolutePath)).toEqual([
+      'resolve-config/.redocly.yaml',
+      'resolve-config/.redocly.yaml',
+    ]);
+    expect(lint.pluginPaths!.map(removeAbsolutePath)).toEqual([]);
+  });
+});
+
+describe('resolveApis', () => {
+  it('should resolve apis lintConfig and merge minimal extends', async () => {
+    const rawConfig: RawConfig = {
+      apis: {
+        petstore: {
+          root: 'some/path',
+          lint: {},
+        },
+      },
+      lint: {
+        extends: ['minimal'],
+      },
+    };
+    const apisResult = await resolveApis({ rawConfig });
+    expect(apisResult['petstore'].lint).toEqual(await minimalLintPreset);
+  });
+
+  it('should not merge recommended extends by default by every level', async () => {
+    const rawConfig: RawConfig = {
+      apis: {
+        petstore: {
+          root: 'some/path',
+          lint: {},
+        },
+      },
+      lint: {},
+    };
+
+    const apisResult = await resolveApis({ rawConfig, configPath });
+
+    expect(apisResult['petstore'].lint.extendPaths!.map(removeAbsolutePath)).toEqual([
+      'resolve-config/.redocly.yaml',
+    ]);
+    expect(apisResult['petstore'].lint.pluginPaths!.map(removeAbsolutePath)).toEqual([]);
+
+    expect(apisResult['petstore'].lint.rules).toEqual({});
+    //@ts-ignore
+    expect(apisResult['petstore'].lint.plugins.length).toEqual(1);
+    //@ts-ignore
+    expect(apisResult['petstore'].lint.plugins[0].id).toEqual('');
+  });
+
+  it('should resolve apis lintConfig when it contains file and not set recommended', async () => {
+    const rawConfig: RawConfig = {
+      apis: {
+        petstore: {
+          root: 'some/path',
+          lint: {
+            rules: {
+              'operation-4xx-response': 'error',
+            },
+          },
+        },
+      },
+      lint: {
+        rules: {
+          'operation-2xx-response': 'warn',
+        },
+      },
+    };
+
+    const apisResult = await resolveApis({ rawConfig, configPath });
+    expect(apisResult['petstore'].lint.rules).toEqual({
+      'operation-2xx-response': 'warn',
+      'operation-4xx-response': 'error',
+    });
+    //@ts-ignore
+    expect(apisResult['petstore'].lint.plugins.length).toEqual(1);
+    //@ts-ignore
+    expect(apisResult['petstore'].lint.plugins[0].id).toEqual('');
+
+    expect(apisResult['petstore'].lint.extendPaths!.map(removeAbsolutePath)).toEqual([
+      'resolve-config/.redocly.yaml',
+    ]);
+    expect(apisResult['petstore'].lint.pluginPaths!.map(removeAbsolutePath)).toEqual([]);
+  });
+
+  it('should resolve apis lintConfig when it contains file', async () => {
+    const rawConfig: RawConfig = {
+      apis: {
+        petstore: {
+          root: 'some/path',
+          lint: {
+            extends: ['local-config.yaml'],
+            rules: {
+              'operation-4xx-response': 'error',
+            },
+          },
+        },
+      },
+      lint: {
+        extends: ['minimal'],
+        rules: {
+          'operation-2xx-response': 'warn',
+        },
+      },
+    };
+
+    const apisResult = await resolveApis({ rawConfig, configPath });
+    expect(apisResult['petstore'].lint.rules).toBeDefined();
+    expect(apisResult['petstore'].lint.rules?.['operation-2xx-response']).toEqual('warn'); // think about prioritize in merge ???
+    expect(apisResult['petstore'].lint.rules?.['operation-4xx-response']).toEqual('error');
+    expect(apisResult['petstore'].lint.rules?.['local/operation-id-not-test']).toEqual('error');
+    //@ts-ignore
+    expect(apisResult['petstore'].lint.plugins.length).toEqual(2);
+
+    expect(apisResult['petstore'].lint.extendPaths!.map(removeAbsolutePath)).toEqual([
+      'resolve-config/.redocly.yaml',
+      'resolve-config/local-config.yaml',
+      'resolve-config/.redocly.yaml',
+    ]);
+    expect(apisResult['petstore'].lint.pluginPaths!.map(removeAbsolutePath)).toEqual([
+      'resolve-config/plugin.js',
+    ]);
+  });
+});
+
+describe('resolveConfig', () => {
+  it('should add recommended to top level by default', async () => {
+    const rawConfig: RawConfig = {
+      apis: {
+        petstore: {
+          root: 'some/path',
+          lint: {
+            rules: {
+              'operation-4xx-response': 'error',
+            },
+          },
+        },
+      },
+      lint: {
+        rules: {
+          'operation-2xx-response': 'warn',
+        },
+      },
+    };
+
+    const { apis } = await resolveConfig(rawConfig, configPath);
+    //@ts-ignore
+    expect(apis['petstore'].lint.plugins.length).toEqual(1);
+    //@ts-ignore
+    expect(apis['petstore'].lint.plugins[0].id).toEqual('');
+
+    expect(apis['petstore'].lint.extendPaths!.map(removeAbsolutePath)).toEqual([
+      'resolve-config/.redocly.yaml',
+    ]);
+    expect(apis['petstore'].lint.pluginPaths!.map(removeAbsolutePath)).toEqual([]);
+
+    expect(apis['petstore'].lint.rules).toEqual({
+      ...(await recommendedLintPreset).rules,
+      'operation-2xx-response': 'warn',
+      'operation-4xx-response': 'error',
+    });
+  });
+
+  it('should not add recommended to top level by default when apis have extends file', async () => {
+    const rawConfig: RawConfig = {
+      apis: {
+        petstore: {
+          root: 'some/path',
+          lint: {
+            extends: ['local-config.yaml'],
+            rules: {
+              'operation-4xx-response': 'error',
+            },
+          },
+        },
+      },
+      lint: {
+        rules: {
+          'operation-2xx-response': 'warn',
+        },
+      },
+    };
+
+    const { apis } = await resolveConfig(rawConfig, configPath);
+    expect(apis['petstore'].lint.rules).toBeDefined();
+    expect(Object.keys(apis['petstore'].lint.rules || {}).length).toEqual(7);
+    expect(apis['petstore'].lint.rules?.['operation-2xx-response']).toEqual('warn');
+    expect(apis['petstore'].lint.rules?.['operation-4xx-response']).toEqual('error');
+    expect(apis['petstore'].lint.rules?.['operation-description']).toEqual('error'); // from extends file config
+    //@ts-ignore
+    expect(apis['petstore'].lint.plugins.length).toEqual(2);
+
+    expect(apis['petstore'].lint.extendPaths!.map(removeAbsolutePath)).toEqual([
+      'resolve-config/.redocly.yaml',
+      'resolve-config/local-config.yaml',
+      'resolve-config/.redocly.yaml',
+    ]);
+    expect(apis['petstore'].lint.pluginPaths!.map(removeAbsolutePath)).toEqual([
+      'resolve-config/plugin.js',
+    ]);
+
+    expect(apis['petstore'].lint.recommendedFallback).toBe(false);
+  });
+
+  it('should ignore minimal from the root and read local file', async () => {
+    const rawConfig: RawConfig = {
+      apis: {
+        petstore: {
+          root: 'some/path',
+          lint: {
+            extends: ['recommended', 'local-config.yaml'],
+            rules: {
+              'operation-4xx-response': 'error',
+            },
+          },
+        },
+      },
+      lint: {
+        extends: ['minimal'],
+        rules: {
+          'operation-2xx-response': 'warn',
+        },
+      },
+    };
+
+    const { apis } = await resolveConfig(rawConfig, configPath);
+    expect(apis['petstore'].lint.rules).toBeDefined();
+    expect(apis['petstore'].lint.rules?.['operation-2xx-response']).toEqual('warn');
+    expect(apis['petstore'].lint.rules?.['operation-4xx-response']).toEqual('error');
+    expect(apis['petstore'].lint.rules?.['operation-description']).toEqual('error'); // from extends file config
+    //@ts-ignore
+    expect(apis['petstore'].lint.plugins.length).toEqual(2);
+    //@ts-ignore
+    delete apis['petstore'].lint.plugins;
+
+    expect(apis['petstore'].lint.extendPaths!.map(removeAbsolutePath)).toEqual([
+      'resolve-config/.redocly.yaml',
+      'resolve-config/local-config.yaml',
+      'resolve-config/.redocly.yaml',
+    ]);
+    expect(apis['petstore'].lint.pluginPaths!.map(removeAbsolutePath)).toEqual([
+      'resolve-config/plugin.js',
+    ]);
+
+    delete apis['petstore'].lint.extendPaths;
+    delete apis['petstore'].lint.pluginPaths;
+    expect(apis['petstore'].lint).toMatchSnapshot();
+  });
+});