@redocly/openapi-core 1.0.0-rc.3 → 1.0.1

package/src/__tests__/lint.test.ts

@@ -0,0 +1,392 @@
+import * as path from 'path';
+import { outdent } from 'outdent';
+
+import { lintFromString, lintConfig, lintDocument } from '../lint';
+import { BaseResolver } from '../resolve';
+import { loadConfig } from '../config/load';
+import { parseYamlToDocument, replaceSourceWithRef, makeConfig } from '../../__tests__/utils';
+import { detectOpenAPI } from '../oas-types';
+
+describe('lint', () => {
+  it('lintFromString should work', async () => {
+    const results = await lintFromString({
+      absoluteRef: '/test/spec.yaml',
+      source: outdent`
+        openapi: 3.0.0
+        info:
+          title: Test API
+          version: "1.0"
+          description: Test
+          license: Fail
+
+        servers:
+          - url: http://example.com
+        paths: {}
+    `,
+      config: await loadConfig(),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "from": undefined,
+          "location": Array [
+            Object {
+              "pointer": "#/info/license",
+              "reportOnKey": false,
+              "source": "/test/spec.yaml",
+            },
+          ],
+          "message": "Expected type \`License\` (object) but got \`string\`",
+          "ruleId": "spec",
+          "severity": "error",
+          "suggest": Array [],
+        },
+      ]
+    `);
+  });
+
+  it('lintConfig should work', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+        apis: error string
+        plugins:
+          - './local-plugin.js'
+        extends:
+          - recommended
+          - local/all
+        rules:
+          operation-2xx-response: warn
+          no-invalid-media-type-examples: error
+          path-http-verbs-order: error
+          boolean-parameter-prefixes: off
+          rule/operation-summary-length:
+            subject: 
+              type: Operation
+              property: summary
+            message: Operation summary should start with an active verb
+            assertions:
+              local/checkWordsCount: 
+                min: 3
+      theme:
+        openapi:
+          showConsole: true
+          layout:
+            scope: section
+          routingStrategy: browser
+          theme:
+            rightPanel:
+              backgroundColor: '#263238'
+            links:
+              color: '#6CC496'
+            theme:
+              openapi:
+              showConsole: true
+              layout:
+                scope: section
+              routingStrategy: browser
+              theme:
+                rightPanel:
+                  backgroundColor: '#263238'
+                links:
+                  color: '#6CC496'
+      `,
+      ''
+    );
+    const results = await lintConfig({ document });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "from": undefined,
+          "location": Array [
+            Object {
+              "pointer": "#/eme",
+              "reportOnKey": true,
+              "source": "",
+            },
+          ],
+          "message": "Property \`eme\` is not expected here.",
+          "ruleId": "configuration spec",
+          "severity": "error",
+          "suggest": Array [
+            "theme",
+            "seo",
+            "sso",
+          ],
+        },
+        Object {
+          "from": undefined,
+          "location": Array [
+            Object {
+              "pointer": "#/openapi",
+              "reportOnKey": true,
+              "source": "",
+            },
+          ],
+          "message": "Property \`openapi\` is not expected here.",
+          "ruleId": "configuration spec",
+          "severity": "error",
+          "suggest": Array [],
+        },
+        Object {
+          "from": undefined,
+          "location": Array [
+            Object {
+              "pointer": "#/apis",
+              "reportOnKey": false,
+              "source": "",
+            },
+          ],
+          "message": "Expected type \`ConfigApis\` (object) but got \`string\`",
+          "ruleId": "configuration spec",
+          "severity": "error",
+          "suggest": Array [],
+        },
+      ]
+    `);
+  });
+
+  it('lintConfig should detect wrong fields and suggest correct ones', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+        api:
+          name@version:
+            root: ./file.yaml
+        rules:
+          operation-2xx-response: warn
+      `,
+      ''
+    );
+    const results = await lintConfig({ document });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "from": undefined,
+          "location": Array [
+            Object {
+              "pointer": "#/api",
+              "reportOnKey": true,
+              "source": "",
+            },
+          ],
+          "message": "Property \`api\` is not expected here.",
+          "ruleId": "configuration spec",
+          "severity": "error",
+          "suggest": Array [
+            "apis",
+            "seo",
+            "sso",
+          ],
+        },
+      ]
+    `);
+  });
+
+  it('lintConfig should work with legacy fields - referenceDocs', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+        apis: 
+          entry: 
+            root: ./file.yaml
+        rules:
+          operation-2xx-response: warn
+        referenceDocs:
+          showConsole: true
+      `,
+      ''
+    );
+    const results = await lintConfig({ document });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "from": undefined,
+          "location": Array [
+            Object {
+              "pointer": "#/referenceDocs",
+              "reportOnKey": true,
+              "source": "",
+            },
+          ],
+          "message": "Property \`referenceDocs\` is not expected here.",
+          "ruleId": "configuration spec",
+          "severity": "error",
+          "suggest": Array [],
+        },
+      ]
+    `);
+  });
+
+  it("'plugins' shouldn't be allowed in 'apis'", async () => {
+    const document = parseYamlToDocument(
+      outdent`
+        apis:
+          main:
+            root: ./main.yaml
+            plugins:
+            - './local-plugin.js'
+        plugins:
+        - './local-plugin.js'
+      `,
+      ''
+    );
+    const results = await lintConfig({ document });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "from": undefined,
+          "location": Array [
+            Object {
+              "pointer": "#/apis/main/plugins",
+              "reportOnKey": true,
+              "source": "",
+            },
+          ],
+          "message": "Property \`plugins\` is not expected here.",
+          "ruleId": "configuration spec",
+          "severity": "error",
+          "suggest": Array [],
+        },
+      ]
+    `);
+  });
+
+  it("'const' can have any type", async () => {
+    const document = parseYamlToDocument(
+      outdent`
+        openapi: "3.1.0"
+        info:
+          version: 1.0.0
+          title: Swagger Petstore
+          description: Information about Petstore
+          license:
+            name: MIT
+            url: https://opensource.org/licenses/MIT
+        servers:
+          - url: http://petstore.swagger.io/v1
+        paths:
+          /pets:
+            get:
+              summary: List all pets
+              operationId: listPets
+              tags:
+                - pets
+              responses:
+                200:
+                  description: An paged array of pets
+                  content:
+                    application/json:
+                      schema:
+                        type: string
+                        const: ABC
+        `,
+      'foobar.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ spec: 'error' }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`Array []`);
+  });
+
+  it('detect OpenAPI should throw an error when version is not string', () => {
+    const testDocument = parseYamlToDocument(
+      outdent`
+        openapi: 3.0
+      `,
+      ''
+    );
+    expect(() => detectOpenAPI(testDocument.parsed)).toThrow(
+      `Invalid OpenAPI version: should be a string but got "number"`
+    );
+  });
+
+  it("spec rule shouldn't throw an error for named callback", async () => {
+    const document = parseYamlToDocument(
+      outdent`
+        openapi: 3.1.0
+        info:
+          title: Callback test
+          version: 'alpha'
+        components:
+          callbacks:
+            resultCallback:
+              '{$url}':
+                post:
+                  requestBody:
+                    description: Callback payload
+                    content:
+                      'application/json':
+                        schema:
+                          type: object
+                          properties:
+                            test:
+                              type: string
+                  responses:
+                    '200':
+                      description: callback successfully processed
+      `,
+      'foobar.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ spec: 'error' }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`Array []`);
+  });
+
+  it('should ignore error because ignore file passed', async () => {
+    const absoluteRef = path.join(__dirname, 'fixtures/openapi.yaml');
+    const document = parseYamlToDocument(
+      outdent`
+        openapi: 3.0.0
+        info:
+          version: 1.0.0
+          title: Example OpenAPI 3 definition.
+          description: Information about API
+          license:
+            name: MIT
+            url: 'https://opensource.org/licenses/MIT'
+        servers:
+          - url: 'https://redocly.com/v1'
+        paths:
+          '/pets/{petId}':
+            post:
+              responses:
+                '201':
+                  summary: Exist
+                  description: example description
+      `,
+      absoluteRef
+    );
+
+    const configFilePath = path.join(__dirname, 'fixtures');
+
+    const result = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await makeConfig({ 'operation-operationId': 'error' }, undefined, configFilePath),
+    });
+    expect(result).toHaveLength(1);
+    expect(result).toMatchObject([
+      {
+        ignored: true,
+        location: [{ pointer: '#/paths/~1pets~1{petId}/post/operationId' }],
+        message: 'Operation object should contain `operationId` field.',
+        ruleId: 'operation-operationId',
+        severity: 'error',
+      },
+    ]);
+    expect(result[0]).toHaveProperty('ignored', true);
+    expect(result[0]).toHaveProperty('ruleId', 'operation-operationId');
+  });
+});

package/src/__tests__/logger-browser.test.ts

@@ -0,0 +1,53 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import * as colorette from 'colorette';
+import { logger, colorize } from '../logger';
+
+describe('Logger in Browser', () => {
+  it('should call "console.error"', () => {
+    const error = jest.spyOn(console, 'error').mockImplementation();
+
+    logger.error('error');
+
+    expect(error).toBeCalledTimes(1);
+    expect(error).toBeCalledWith('error');
+
+    error.mockRestore();
+  });
+
+  it('should call "console.log"', () => {
+    const log = jest.spyOn(console, 'log').mockImplementation();
+
+    logger.info('info');
+
+    expect(log).toBeCalledTimes(1);
+    expect(log).toBeCalledWith('info');
+
+    log.mockRestore();
+  });
+
+  it('should call "console.warn"', () => {
+    const warn = jest.spyOn(console, 'warn').mockImplementation();
+
+    logger.warn('warn');
+
+    expect(warn).toBeCalledTimes(1);
+    expect(warn).toBeCalledWith('warn');
+
+    warn.mockRestore();
+  });
+});
+
+describe('colorize in Browser', () => {
+  it('should not call original colorette lib', () => {
+    const color = 'cyan';
+    const spyingCyan = jest.spyOn(colorette, color);
+
+    const colorized = colorize.cyan(color);
+
+    expect(spyingCyan).not.toBeCalled();
+    expect(colorized).toEqual(color);
+  });
+});

package/src/__tests__/logger.test.ts

@@ -0,0 +1,47 @@
+import * as colorette from 'colorette';
+import { logger, colorize } from '../logger';
+
+describe('Logger in nodejs', () => {
+  let spyingStderr: jest.SpyInstance;
+
+  beforeEach(() => {
+    spyingStderr = jest.spyOn(process.stderr, 'write').mockImplementation();
+  });
+
+  afterEach(() => {
+    spyingStderr.mockRestore();
+  });
+
+  it('should call "process.stderr.write" for error severity', () => {
+    logger.error('error');
+
+    expect(spyingStderr).toBeCalledTimes(1);
+    expect(spyingStderr).toBeCalledWith(colorette.red('error'));
+  });
+
+  it('should call "process.stderr.write" for warn severity', () => {
+    logger.warn('warn');
+
+    expect(spyingStderr).toBeCalledTimes(1);
+    expect(spyingStderr).toBeCalledWith(colorette.yellow('warn'));
+  });
+
+  it('should call "process.stderr.write" for info severity', () => {
+    logger.info('info');
+
+    expect(spyingStderr).toBeCalledTimes(1);
+    expect(spyingStderr).toBeCalledWith('info');
+  });
+});
+
+describe('colorize in nodejs', () => {
+  it('should call original colorette lib', () => {
+    const color = 'cyan';
+    const spyingCyan = jest.spyOn(colorette, color);
+
+    const colorized = colorize.cyan(color);
+
+    expect(spyingCyan).toBeCalledWith(color);
+    expect(colorized).toEqual(colorette[color](color));
+  });
+});

package/src/__tests__/login.test.ts

@@ -0,0 +1,17 @@
+import { RedoclyClient } from '../redocly';
+
+describe.skip('login', () => {
+  it('should call login with setAccessTokens function', async () => {
+    const client = new RedoclyClient();
+    Object.defineProperty(client, 'registryApi', {
+      value: {
+        setAccessTokens: jest.fn(),
+        authStatus: jest.fn(() => true),
+      },
+      writable: true,
+      configurable: true,
+    });
+    await client.login('token'); // TODO: bug with rewrite local config file
+    expect(client.registryApi.setAccessTokens).toHaveBeenCalled();
+  });
+});

package/src/__tests__/normalizeVisitors.test.ts

@@ -0,0 +1,151 @@
+import { normalizeVisitors, VisitorLevelContext } from '../visitors';
+import { Oas3RuleSet } from '../oas-types';
+import { Oas3Types } from '../types/oas3';
+import { normalizeTypes } from '../types';
+
+describe('Normalize visitors', () => {
+  it('should work correctly for single rule', () => {
+    const schemaEnter = () => undefined;
+
+    const ruleset: Oas3RuleSet[] = [
+      {
+        test: () => {
+          return {
+            Schema: schemaEnter,
+          };
+        },
+      },
+    ];
+
+    const visitors = ruleset.flatMap((ruleset) =>
+      Object.keys(ruleset).map((ruleId) => ({
+        ruleId,
+        severity: 'error' as 'error',
+        visitor: ruleset[ruleId]({}),
+      }))
+    );
+
+    const normalized = normalizeVisitors(visitors, normalizeTypes(Oas3Types));
+    expect(normalized).toBeDefined();
+    expect(normalized.Schema.enter).toHaveLength(1);
+    expect(normalized.Schema.enter[0].visit).toEqual(schemaEnter);
+    expect(normalized.Schema.enter[0].context.parent).toEqual(null);
+    const { type, ...contextWithoutType } = normalized.Schema.enter[0]
+      .context as VisitorLevelContext;
+
+    expect(contextWithoutType).toEqual({
+      activatedOn: null,
+      parent: null,
+      isSkippedLevel: false,
+    });
+
+    expect(type.name).toEqual('Schema');
+  });
+
+  it('should work for nested rule', () => {
+    const infoEnter = () => undefined;
+    const infoLeave = () => undefined;
+    const contactEnter = () => undefined;
+
+    const ruleset: Oas3RuleSet[] = [
+      {
+        test: () => {
+          return {
+            Info: {
+              enter: infoEnter,
+              leave: infoLeave,
+              Contact: contactEnter,
+            },
+          };
+        },
+      },
+    ];
+
+    const visitors = ruleset.flatMap((ruleset) =>
+      Object.keys(ruleset).map((ruleId) => ({
+        ruleId,
+        severity: 'error' as 'error',
+        visitor: ruleset[ruleId]({}),
+      }))
+    );
+
+    const normalized = normalizeVisitors(visitors, normalizeTypes(Oas3Types));
+    expect(normalized).toBeDefined();
+    expect(normalized.Info.enter).toHaveLength(1);
+
+    expect(normalized.Info.enter[0].context).toStrictEqual(normalized.Info.leave[0].context);
+
+    expect(normalized.Info.enter[0].visit).toEqual(infoEnter);
+    expect(normalized.Contact.enter[0].visit).toEqual(contactEnter);
+
+    expect(normalized.Contact.enter[0].context.parent).toEqual(normalized.Info.enter[0].context);
+
+    expect(normalized.Info.leave).toHaveLength(1);
+    expect(normalized.Info.leave[0].visit).toEqual(infoLeave);
+  });
+
+  it('should normalize with weak intermittent types', () => {
+    const contactEnter = () => undefined;
+
+    const ruleset: Oas3RuleSet[] = [
+      {
+        test: () => {
+          return {
+            PathItem: {
+              Parameter: contactEnter,
+            },
+          };
+        },
+      },
+    ];
+
+    const visitors = ruleset.flatMap((ruleset) =>
+      Object.keys(ruleset).map((ruleId) => ({
+        ruleId,
+        severity: 'error' as 'error',
+        visitor: ruleset[ruleId]({}),
+      }))
+    );
+
+    const normalized = normalizeVisitors(visitors, normalizeTypes(Oas3Types));
+    expect(normalized).toBeDefined();
+    expect(normalized.PathItem.enter).toHaveLength(1);
+    expect(normalized.Operation.enter).toHaveLength(1);
+    expect(normalized.Parameter.enter).toHaveLength(1);
+    expect(normalized.ParameterList.enter).toHaveLength(2);
+  });
+
+  it('should order deeper visitors first', () => {
+    const pathParam = () => undefined;
+    const operationParam = () => undefined;
+
+    const ruleset: Oas3RuleSet[] = [
+      {
+        test: () => {
+          return {
+            PathItem: {
+              Parameter: pathParam,
+              Operation: {
+                Parameter: operationParam,
+              },
+            },
+          };
+        },
+      },
+    ];
+
+    const visitors = ruleset.flatMap((ruleset) =>
+      Object.keys(ruleset).map((ruleId) => ({
+        ruleId,
+        severity: 'error' as 'error',
+        visitor: ruleset[ruleId]({}),
+      }))
+    );
+
+    const normalized = normalizeVisitors(visitors, normalizeTypes(Oas3Types));
+    expect(normalized).toBeDefined();
+    expect(normalized.Parameter.enter).toHaveLength(2);
+    expect(normalized.Parameter.enter[0].visit).toStrictEqual(operationParam);
+    expect(normalized.Parameter.enter[1].visit).toStrictEqual(pathParam);
+  });
+});

package/src/__tests__/output-browser.test.ts

@@ -0,0 +1,18 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import { output } from '../output';
+
+describe('output', () => {
+  it('should ignore all parsable data in browser', () => {
+    const spyingStdout = jest.spyOn(process.stdout, 'write').mockImplementation();
+    const data = '{ "errors" : [] }';
+
+    output.write(data);
+
+    expect(spyingStdout).not.toBeCalled();
+
+    spyingStdout.mockRestore();
+  });
+});

package/src/__tests__/output.test.ts

@@ -0,0 +1,15 @@
+import { output } from '../output';
+
+describe('output', () => {
+  it('should write all parsable data to stdout', () => {
+    const spyingStdout = jest.spyOn(process.stdout, 'write').mockImplementation();
+    const data = '{ "errors" : [] }';
+
+    output.write(data);
+
+    expect(spyingStdout).toBeCalledTimes(1);
+    expect(spyingStdout).toBeCalledWith(data);
+
+    spyingStdout.mockRestore();
+  });
+});