@redocly/openapi-core 1.34.4 → 2.0.0-next.0

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,169 +0,0 @@
-import {
-  BaseVisitor,
-  NestedVisitObject,
-  normalizeVisitors,
-  RuleInstanceConfig,
-  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 as (RuleInstanceConfig & { visitor: NestedVisitObject<any, BaseVisitor> })[],
-      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 as (RuleInstanceConfig & { visitor: NestedVisitObject<any, BaseVisitor> })[],
-      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 as (RuleInstanceConfig & { visitor: NestedVisitObject<any, BaseVisitor> })[],
-      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 as (RuleInstanceConfig & { visitor: NestedVisitObject<any, BaseVisitor> })[],
-      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();
-  });
-});

package/src/__tests__/ref-utils.test.ts

@@ -1,142 +0,0 @@
-import outdent from 'outdent';
-import { parseYamlToDocument } from '../../__tests__/utils';
-import { parseRef, refBaseName } from '../ref-utils';
-import { lintDocument } from '../lint';
-import { StyleguideConfig } from '../config';
-import { BaseResolver } from '../resolve';
-
-describe('ref-utils', () => {
-  it(`should unescape refs with '/'`, () => {
-    const reference = 'somefile.yaml#/components/schemas/scope~1domain-schema';
-    expect(parseRef(reference)).toMatchInlineSnapshot(`
-      {
-        "pointer": [
-          "components",
-          "schemas",
-          "scope/domain-schema",
-        ],
-        "uri": "somefile.yaml",
-      }
-    `);
-  });
-
-  it(`should unescape refs with '~'`, () => {
-    const reference = 'somefile.yaml#/components/schemas/complex~0name';
-    expect(parseRef(reference)).toMatchInlineSnapshot(`
-      {
-        "pointer": [
-          "components",
-          "schemas",
-          "complex~name",
-        ],
-        "uri": "somefile.yaml",
-      }
-    `);
-  });
-
-  it(`should unescape complex urlencoded paths`, () => {
-    const referene = 'somefile.yaml#/components/schemas/scope%2Fcomplex~name';
-    expect(parseRef(referene)).toMatchInlineSnapshot(`
-      {
-        "pointer": [
-          "components",
-          "schemas",
-          "scope/complex~name",
-        ],
-        "uri": "somefile.yaml",
-      }
-    `);
-  });
-
-  it(`should validate definition with urlencoded paths`, async () => {
-    const document = parseYamlToDocument(
-      outdent` 
-        openapi: "3.0.0"
-        info:
-          version: 1.0.0
-          title: Swagger Petstore
-          description: Test definition
-          license:
-            name: MIT
-            url: https://opensource.org/licenses/MIT
-        servers:
-          - url: http://petstore.swagger.io/v1
-        paths:
-          /pet:
-            get:
-              summary: List all pets
-              operationId: listPets
-              responses:
-                '200':
-                  description: A paged array of pets
-                  content:
-                    application/json:
-                      schema:
-                        $ref: "#/components/schemas/scope%3A%7Banimals~1Pet%7D"
-        components:
-          schemas:
-            scope:{animals/Pet}:
-              type: object
-              properties:
-                id:
-                  type: integer
-                  format: int64
-                name:
-                  type: string
-      `,
-      ''
-    );
-
-    const result = await lintDocument({
-      document,
-      externalRefResolver: new BaseResolver(),
-      config: new StyleguideConfig({}),
-    });
-
-    expect(result).toMatchInlineSnapshot(`[]`);
-  });
-
-  it('should parse a ref correctly', () => {
-    expect(parseRef('./info.yaml#/description')).toEqual({
-      uri: './info.yaml',
-      pointer: ['description'],
-    });
-  });
-
-  it('should parse a ref which contain a hash in the middle', () => {
-    // Here `info#description.md` is a file name
-    expect(parseRef('./info#description.md')).toEqual({
-      uri: './info#description.md',
-      pointer: [],
-    });
-  });
-
-  it('should parse a ref which ends with a hash', () => {
-    expect(parseRef('./info.yaml#')).toEqual({
-      uri: './info.yaml',
-      pointer: [],
-    });
-  });
-
-  describe('refBaseName', () => {
-    it('returns base name for file reference', () => {
-      expect(refBaseName('../testcase/Pet.yaml')).toStrictEqual('Pet');
-    });
-
-    it('returns base name for local file reference', () => {
-      expect(refBaseName('Cat.json')).toStrictEqual('Cat');
-    });
-
-    it('returns base name for url reference', () => {
-      expect(refBaseName('http://example.com/tests/crocodile.json')).toStrictEqual('crocodile');
-    });
-
-    it('returns base name for file with multiple dots in name', () => {
-      expect(refBaseName('feline.tiger.v1.yaml')).toStrictEqual('feline.tiger.v1');
-    });
-
-    it('returns base name for file without any dots in name', () => {
-      expect(refBaseName('abcdefg')).toStrictEqual('abcdefg');
-    });
-  });
-});

package/src/__tests__/resolve-http.test.ts

@@ -1,77 +0,0 @@
-import { outdent } from 'outdent';
-
-import { resolveDocument, BaseResolver } from '../resolve';
-import { parseYamlToDocument } from '../../__tests__/utils';
-import { Oas3Types } from '../types/oas3';
-import { normalizeTypes } from '../types';
-
-describe('Resolve http-headers', () => {
-  it('should use matching http-headers', async () => {
-    const rootDocument = parseYamlToDocument(
-      outdent`
-        openapi: 3.0.0
-        components:
-          schemas:
-            A:
-              $ref: 'https://example.com/test.yaml'
-            B:
-              $ref: 'https://sample.com/test.yaml'
-            C:
-              $ref: 'https://sample.com/test/a/test.yaml'
-      `,
-      'foobar.yaml'
-    );
-
-    const fetchMock = jest.fn(() => Promise.resolve({ ok: true, text: Promise.resolve('') }));
-
-    await resolveDocument({
-      rootDocument,
-      externalRefResolver: new BaseResolver({
-        http: {
-          customFetch: fetchMock,
-          headers: [
-            {
-              name: 'X_TEST',
-              matches: 'example.com/*',
-              value: '123',
-            },
-            {
-              name: 'X_TEST',
-              matches: 'https://sample.com/test/**',
-              value: '321',
-            },
-          ],
-        },
-      }),
-      rootType: normalizeTypes(Oas3Types).Root,
-    });
-
-    expect(fetchMock).toBeCalledTimes(3);
-    expect(fetchMock.mock.calls).toMatchInlineSnapshot(`
-      [
-        [
-          "https://example.com/test.yaml",
-          {
-            "headers": {
-              "X_TEST": "123",
-            },
-          },
-        ],
-        [
-          "https://sample.com/test.yaml",
-          {
-            "headers": {},
-          },
-        ],
-        [
-          "https://sample.com/test/a/test.yaml",
-          {
-            "headers": {
-              "X_TEST": "321",
-            },
-          },
-        ],
-      ]
-    `);
-  });
-});