@redocly/openapi-core 1.0.0-beta.126 → 1.0.0-beta.128

package/src/__tests__/lint.test.ts

@@ -1,388 +0,0 @@
-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
-          assert/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",
-          ],
-        },
-        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",
-          ],
-        },
-      ]
-    `);
-  });
-
-  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

@@ -1,53 +0,0 @@
-/**
- * @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

@@ -1,47 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,151 +0,0 @@
-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

@@ -1,18 +0,0 @@
-/**
- * @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

@@ -1,15 +0,0 @@
-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();
-  });
-});