@redocly/openapi-core 1.0.0-beta.93 → 1.0.0-beta.96

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();
+  });
+});

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

@@ -0,0 +1,244 @@
+import { Config } from '../config';
+import { getMergedConfig } from '../utils';
+
+const testConfig: Config = {
+  rawConfig: {
+    apis: {
+      'test@v1': {
+        root: 'resources/pets.yaml',
+        lint: { rules: { 'operation-summary': 'warn' } },
+      },
+    },
+    organization: 'redocly-test',
+    lint: {
+      rules: { 'operation-summary': 'error', 'no-empty-servers': 'error' },
+      plugins: [],
+    },
+  },
+  configFile: 'redocly.yaml',
+  apis: {
+    'test@v1': {
+      root: 'resources/pets.yaml',
+      lint: { rules: { 'operation-summary': 'warn' } },
+    },
+  },
+  // @ts-ignore
+  lint: {
+    rawConfig: {
+      rules: { 'operation-summary': 'error', 'no-empty-servers': 'error' },
+      plugins: [],
+    },
+    configFile: 'redocly.yaml',
+    ignore: {},
+    _usedRules: new Set(),
+    _usedVersions: new Set(),
+    recommendedFallback: false,
+    plugins: [],
+    doNotResolveExamples: false,
+    rules: {
+      oas2: { 'operation-summary': 'error', 'no-empty-servers': 'error' },
+      oas3_0: { 'operation-summary': 'error', 'no-empty-servers': 'error' },
+      oas3_1: { 'operation-summary': 'error', 'no-empty-servers': 'error' },
+    },
+    preprocessors: { oas2: {}, oas3_0: {}, oas3_1: {} },
+    decorators: { oas2: {}, oas3_0: {}, oas3_1: {} },
+  },
+  'features.openapi': {},
+  'features.mockServer': {},
+  resolve: { http: { headers: [] } },
+  organization: 'redocly-test',
+};
+
+describe('getMergedConfig', () => {
+  it('should get lint defined in "apis" section', () => {
+    expect(getMergedConfig(testConfig, 'test@v1')).toMatchInlineSnapshot(`
+      Config {
+        "apis": Object {
+          "test@v1": Object {
+            "lint": Object {
+              "rules": Object {
+                "operation-summary": "warn",
+              },
+            },
+            "root": "resources/pets.yaml",
+          },
+        },
+        "configFile": "redocly.yaml",
+        "features.mockServer": Object {},
+        "features.openapi": Object {},
+        "lint": LintConfig {
+          "_usedRules": Set {},
+          "_usedVersions": Set {},
+          "configFile": "redocly.yaml",
+          "decorators": Object {
+            "oas2": Object {},
+            "oas3_0": Object {},
+            "oas3_1": Object {},
+          },
+          "doNotResolveExamples": false,
+          "extendPaths": Array [],
+          "ignore": Object {},
+          "pluginPaths": Array [],
+          "plugins": Array [],
+          "preprocessors": Object {
+            "oas2": Object {},
+            "oas3_0": Object {},
+            "oas3_1": Object {},
+          },
+          "rawConfig": Object {
+            "extendPaths": Array [],
+            "pluginPaths": Array [],
+            "rules": Object {
+              "operation-summary": "warn",
+            },
+          },
+          "recommendedFallback": false,
+          "rules": Object {
+            "oas2": Object {
+              "operation-summary": "warn",
+            },
+            "oas3_0": Object {
+              "operation-summary": "warn",
+            },
+            "oas3_1": Object {
+              "operation-summary": "warn",
+            },
+          },
+        },
+        "organization": "redocly-test",
+        "rawConfig": Object {
+          "apis": Object {
+            "test@v1": Object {
+              "lint": Object {
+                "rules": Object {
+                  "operation-summary": "warn",
+                },
+              },
+              "root": "resources/pets.yaml",
+            },
+          },
+          "features.mockServer": Object {},
+          "features.openapi": Object {},
+          "lint": Object {
+            "extendPaths": Array [],
+            "pluginPaths": Array [],
+            "rules": Object {
+              "operation-summary": "warn",
+            },
+          },
+          "organization": "redocly-test",
+        },
+        "region": undefined,
+        "resolve": Object {
+          "http": Object {
+            "customFetch": undefined,
+            "headers": Array [],
+          },
+        },
+      }
+    `);
+  });
+  it('should take into account a config file', () => {
+    const result = getMergedConfig(testConfig, 'test@v1');
+    expect(result.configFile).toEqual('redocly.yaml');
+    expect(result.lint.configFile).toEqual('redocly.yaml');
+  });
+  it('should return the same config when there is no alias provided', () => {
+    expect(getMergedConfig(testConfig)).toEqual(testConfig);
+  });
+  it('should handle wrong alias - return the same lint, empty features', () => {
+    expect(getMergedConfig(testConfig, 'wrong-alias')).toMatchInlineSnapshot(`
+      Config {
+        "apis": Object {
+          "test@v1": Object {
+            "lint": Object {
+              "rules": Object {
+                "operation-summary": "warn",
+              },
+            },
+            "root": "resources/pets.yaml",
+          },
+        },
+        "configFile": "redocly.yaml",
+        "features.mockServer": Object {},
+        "features.openapi": Object {},
+        "lint": LintConfig {
+          "_usedRules": Set {},
+          "_usedVersions": Set {},
+          "configFile": "redocly.yaml",
+          "decorators": Object {
+            "oas2": Object {},
+            "oas3_0": Object {},
+            "oas3_1": Object {},
+          },
+          "doNotResolveExamples": false,
+          "extendPaths": Array [],
+          "ignore": Object {},
+          "pluginPaths": Array [],
+          "plugins": Array [],
+          "preprocessors": Object {
+            "oas2": Object {},
+            "oas3_0": Object {},
+            "oas3_1": Object {},
+          },
+          "rawConfig": Object {
+            "extendPaths": Array [],
+            "pluginPaths": Array [],
+            "plugins": Array [],
+            "rules": Object {
+              "no-empty-servers": "error",
+              "operation-summary": "error",
+            },
+          },
+          "recommendedFallback": false,
+          "rules": Object {
+            "oas2": Object {
+              "no-empty-servers": "error",
+              "operation-summary": "error",
+            },
+            "oas3_0": Object {
+              "no-empty-servers": "error",
+              "operation-summary": "error",
+            },
+            "oas3_1": Object {
+              "no-empty-servers": "error",
+              "operation-summary": "error",
+            },
+          },
+        },
+        "organization": "redocly-test",
+        "rawConfig": Object {
+          "apis": Object {
+            "test@v1": Object {
+              "lint": Object {
+                "rules": Object {
+                  "operation-summary": "warn",
+                },
+              },
+              "root": "resources/pets.yaml",
+            },
+          },
+          "features.mockServer": Object {},
+          "features.openapi": Object {},
+          "lint": Object {
+            "extendPaths": Array [],
+            "pluginPaths": Array [],
+            "plugins": Array [],
+            "rules": Object {
+              "no-empty-servers": "error",
+              "operation-summary": "error",
+            },
+          },
+          "organization": "redocly-test",
+        },
+        "region": undefined,
+        "resolve": Object {
+          "http": Object {
+            "customFetch": undefined,
+            "headers": Array [],
+          },
+        },
+      }
+    `);
+  });
+});

package/src/config/__tests__/fixtures/plugin.js

@@ -21,7 +21,7 @@ const rules = {
       return {
         SecurityScheme(scheme, { location, report }) {
           if (scheme.type === 'openIdConnect') {
-            if (!scheme.openIdConnectUrl?.endsWith('/.well-known/openid-configuration')) {
+            if (!scheme.openIdConnectUrl.endsWith('/.well-known/openid-configuration')) {
               report({
                 message:
                   'openIdConnectUrl must be a URL that ends with /.well-known/openid-configuration',

package/src/config/__tests__/fixtures/resolve-config/api/nested-config.yaml

@@ -0,0 +1,7 @@
+lint:
+  plugins:
+    - plugin.js
+  rules:
+    operation-2xx-response: error
+  extends:
+    - test-plugin-nested/all