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

package/src/__tests__/resolve.test.ts

@@ -1,431 +0,0 @@
-import { outdent } from 'outdent';
-import * as path from 'path';
-
-import { resolveDocument, BaseResolver, Document } from '../resolve';
-import { parseYamlToDocument } from '../../__tests__/utils';
-import { Oas3Types } from '../types/oas3';
-import { normalizeTypes } from '../types';
-import * as fs from 'fs';
-
-describe('collect refs', () => {
-  it('should resolve local refs', async () => {
-    const rootDocument = parseYamlToDocument(
-      outdent`
-        openapi: 3.0.0
-        info:
-          $ref: "#/defs/info"
-        defs:
-          info:
-            contact: {}
-            license: {}
-      `,
-      'foobar.yaml'
-    );
-
-    const resolvedRefs = await resolveDocument({
-      rootDocument,
-      externalRefResolver: new BaseResolver(),
-      rootType: normalizeTypes(Oas3Types).Root,
-    });
-
-    expect(resolvedRefs).toBeDefined();
-    expect(resolvedRefs.size).toEqual(1);
-    expect(Array.from(resolvedRefs.keys())).toMatchInlineSnapshot(
-      [`foobar.yaml::#/defs/info`],
-      `
-      [
-        "foobar.yaml::#/defs/info",
-      ]
-    `
-    );
-    expect(Array.from(resolvedRefs.values()).map((info) => info.node)).toEqual([
-      { contact: {}, license: {} },
-    ]);
-  });
-
-  // Or using async/await.
-  it('should throw on self-circular refs', async () => {
-    expect.assertions(1);
-
-    const rootDocument = parseYamlToDocument(
-      outdent`
-        openapi: 3.0.0
-        info:
-          $ref: "#/info"
-        defs:
-          info:
-            contact: {}
-            license: {}
-      `,
-      ''
-    );
-
-    try {
-      await resolveDocument({
-        rootDocument,
-        externalRefResolver: new BaseResolver(),
-        rootType: normalizeTypes(Oas3Types).Root,
-      });
-    } catch (e) {
-      expect(e.message).toEqual('Self-referencing circular pointer');
-    }
-  });
-
-  it('should resolve local transitive refs', async () => {
-    const rootDocument = parseYamlToDocument(
-      outdent`
-        openapi: 3.0.0
-        info:
-          $ref: "#/tmp/info"
-        tmp:
-          $ref: '#/defs'
-        prop:
-          $ref: '#/propTrans'
-        propTrans:
-          $ref: '#/propDest'
-        propDest:
-          type: string
-        defs:
-          info:
-            contact: {}
-            license: {}
-      `,
-      'foobar.yaml'
-    );
-
-    const resolvedRefs = await resolveDocument({
-      rootDocument,
-      externalRefResolver: new BaseResolver(),
-      rootType: normalizeTypes(Oas3Types).Root,
-    });
-
-    expect(resolvedRefs).toBeDefined();
-    expect(resolvedRefs.size).toEqual(4);
-    expect(Array.from(resolvedRefs.keys())).toEqual([
-      'foobar.yaml::#/defs',
-      'foobar.yaml::#/propDest',
-      'foobar.yaml::#/tmp/info',
-      'foobar.yaml::#/propTrans',
-    ]);
-    expect(Array.from(resolvedRefs.values()).map((info) => info.node)).toEqual([
-      { info: { contact: {}, license: {} } },
-      { type: 'string' },
-      { contact: {}, license: {} },
-      { type: 'string' },
-    ]);
-  });
-
-  it('should throw on ref loop', async () => {
-    const rootDocument = parseYamlToDocument(
-      outdent`
-        openapi: 3.0.0
-        info:
-          $ref: "#/loop"
-        loop:
-          $ref: '#/loop2'
-        loop2:
-          $ref: '#/info'
-      `,
-      'foobar.yaml'
-    );
-
-    try {
-      await resolveDocument({
-        rootDocument,
-        externalRefResolver: new BaseResolver(),
-        rootType: normalizeTypes(Oas3Types).Root,
-      });
-    } catch (e) {
-      expect(e.message).toEqual('Self-referencing circular pointer');
-    }
-  });
-
-  it('should resolve external ref', async () => {
-    const cwd = path.join(__dirname, 'fixtures/resolve');
-    const rootDocument = parseYamlToDocument(
-      outdent`
-        openapi: 3.0.0
-        info:
-          $ref: "./externalInfo.yaml#/info"
-      `,
-      path.join(cwd, 'foobar.yaml')
-    );
-
-    const resolvedRefs = await resolveDocument({
-      rootDocument,
-      externalRefResolver: new BaseResolver(),
-      rootType: normalizeTypes(Oas3Types).Root,
-    });
-
-    expect(resolvedRefs).toBeDefined();
-    // expect(resolvedRefs.size).toEqual(2);
-    expect(Array.from(resolvedRefs.keys()).map((ref) => ref.substring(cwd.length + 1))).toEqual([
-      'foobar.yaml::./externalInfo.yaml#/info',
-      'externalInfo.yaml::./externalLicense.yaml',
-    ]);
-
-    expect(Array.from(resolvedRefs.values()).map((info) => info.node)).toEqual([
-      {
-        contact: {},
-        license: {
-          $ref: './externalLicense.yaml',
-        },
-      },
-      {
-        name: 'MIT',
-      },
-    ]);
-  });
-
-  it('should resolve back references', async () => {
-    const cwd = path.join(__dirname, 'fixtures/resolve');
-    const externalRefResolver = new BaseResolver();
-    const rootDocument = await externalRefResolver.resolveDocument(
-      null,
-      `${cwd}/openapi-with-back.yaml`
-    );
-
-    const resolvedRefs = await resolveDocument({
-      rootDocument: rootDocument as Document,
-      externalRefResolver: externalRefResolver,
-      rootType: normalizeTypes(Oas3Types).Root,
-    });
-
-    expect(resolvedRefs).toBeDefined();
-
-    expect(
-      Array.from(resolvedRefs.keys())
-        .map((ref) => ref.substring(cwd.length + 1))
-        .sort()
-    ).toMatchInlineSnapshot(`
-      [
-        "openapi-with-back.yaml::./schemas/type-a.yaml#/",
-        "openapi-with-back.yaml::./schemas/type-b.yaml#/",
-        "schemas/type-a.yaml::../openapi-with-back.yaml#/components/schemas/TypeB",
-      ]
-    `);
-
-    expect(
-      Array.from(resolvedRefs.values())
-        .map((val) => val.node)
-        .sort((firstEl, secondEl) => {
-          const getKey = (el: any): string => el?.allOf?.type || el?.type || '';
-
-          return getKey(firstEl).localeCompare(getKey(secondEl));
-        })
-    ).toMatchInlineSnapshot(`
-      [
-        {
-          "allOf": [
-            {
-              "properties": {
-                "integration_type": {
-                  "$ref": "../openapi-with-back.yaml#/components/schemas/TypeB",
-                },
-                "name": {
-                  "type": "string",
-                },
-              },
-              "required": [
-                "name",
-                "integration_type",
-              ],
-              "type": "object",
-            },
-          ],
-        },
-        {
-          "enum": [
-            "webhook",
-            "api_key",
-            "sftp",
-            "netsuite",
-          ],
-          "type": "string",
-        },
-        {
-          "enum": [
-            "webhook",
-            "api_key",
-            "sftp",
-            "netsuite",
-          ],
-          "type": "string",
-        },
-      ]
-    `);
-  });
-
-  it('should resolve external refs with circular', async () => {
-    const cwd = path.join(__dirname, 'fixtures/resolve');
-    const externalRefResolver = new BaseResolver();
-    const rootDocument = await externalRefResolver.resolveDocument(null, `${cwd}/openapi.yaml`);
-
-    const resolvedRefs = await resolveDocument({
-      rootDocument: rootDocument as Document,
-      externalRefResolver: externalRefResolver,
-      rootType: normalizeTypes(Oas3Types).Root,
-    });
-
-    expect(resolvedRefs).toBeDefined();
-    expect(Array.from(resolvedRefs.keys()).map((ref) => ref.substring(cwd.length + 1)))
-      .toMatchInlineSnapshot(`
-      [
-        "openapi.yaml::#/components/schemas/Local",
-        "openapi.yaml::#/components/schemas/Local/properties/string",
-        "openapi.yaml::./External.yaml#/properties/string",
-        "openapi.yaml::./External.yaml",
-        "External.yaml::./External2.yaml",
-        "External2.yaml::./External.yaml#/properties",
-      ]
-    `);
-
-    expect(Array.from(resolvedRefs.values()).map((val) => val.node)).toMatchInlineSnapshot(`
-      [
-        {
-          "properties": {
-            "localCircular": {
-              "$ref": "#/components/schemas/Local",
-            },
-            "number": {
-              "type": "number",
-            },
-            "string": {
-              "type": "string",
-            },
-          },
-        },
-        {
-          "type": "string",
-        },
-        {
-          "type": "string",
-        },
-        {
-          "properties": {
-            "external": {
-              "$ref": "./External2.yaml",
-            },
-            "number": {
-              "type": "number",
-            },
-            "string": {
-              "type": "string",
-            },
-            "unknown": {
-              "type": "string",
-            },
-          },
-          "type": "object",
-        },
-        {
-          "properties": {
-            "circularParent": {
-              "$ref": "./External.yaml#/properties",
-            },
-          },
-          "type": "object",
-        },
-        {
-          "external": {
-            "$ref": "./External2.yaml",
-          },
-          "number": {
-            "type": "number",
-          },
-          "string": {
-            "type": "string",
-          },
-          "unknown": {
-            "type": "string",
-          },
-        },
-      ]
-    `);
-  });
-
-  it('should resolve referenceable scalars', async () => {
-    const cwd = path.join(__dirname, 'fixtures/resolve');
-    const externalRefResolver = new BaseResolver();
-    const rootDocument = await externalRefResolver.resolveDocument(
-      null,
-      `${cwd}/openapi-with-md-description.yaml`
-    );
-
-    expect(rootDocument).toBeDefined();
-
-    // @ts-ignore
-    Oas3Types.Info.properties.description['referenceable'] = true;
-    const resolvedRefs = await resolveDocument({
-      rootDocument: rootDocument as Document,
-      externalRefResolver: externalRefResolver,
-      rootType: normalizeTypes(Oas3Types).Root,
-    });
-
-    expect(resolvedRefs).toBeDefined();
-    // expect(resolvedRefs.size).toEqual(2);
-    expect(Array.from(resolvedRefs.keys()).map((ref) => ref.substring(cwd.length + 1)))
-      .toMatchInlineSnapshot(`
-      [
-        "openapi-with-md-description.yaml::./description.md",
-      ]
-    `);
-    expect(Array.from(resolvedRefs.values()).map((val) => val.node)).toMatchInlineSnapshot(`
-      [
-        "# Hello World
-
-      Lorem ipsum
-      ",
-      ]
-    `);
-  });
-
-  it('should resolve external transitive ref', async () => {
-    const cwd = path.join(__dirname, 'fixtures/resolve');
-    const rootDocument = parseYamlToDocument(
-      outdent`
-        openapi: 3.0.0
-        components:
-          $ref: "./transitive/components.yaml#/components/schemas/a"
-      `,
-      path.join(cwd, 'foobar.yaml')
-    );
-
-    const resolvedRefs = await resolveDocument({
-      rootDocument,
-      externalRefResolver: new BaseResolver(),
-      rootType: normalizeTypes(Oas3Types).Root,
-    });
-
-    expect(resolvedRefs).toBeDefined();
-    expect(resolvedRefs.size).toEqual(3);
-    expect(Array.from(resolvedRefs.keys()).map((ref) => ref.substring(cwd.length + 1))).toEqual([
-      'transitive/components.yaml::./schemas.yaml#/schemas',
-      'transitive/schemas.yaml::a.yaml',
-      'foobar.yaml::./transitive/components.yaml#/components/schemas/a',
-    ]);
-
-    expect(Array.from(resolvedRefs.values()).pop()!.node).toEqual({ type: 'string' });
-  });
-
-  it('should throw error if ref is folder', async () => {
-    const cwd = path.join(__dirname, 'fixtures/resolve');
-    const rootDocument = parseYamlToDocument(
-      outdent`
-        openapi: 3.0.0
-        components:
-          $ref: "./transitive/components.yaml#/components/schemas/a"
-      `,
-      path.join(cwd, 'foobar')
-    );
-    jest.spyOn(fs, 'lstatSync').mockImplementation((_) => ({ isDirectory: () => true } as any));
-
-    const resolvedRefs = await resolveDocument({
-      rootDocument,
-      externalRefResolver: new BaseResolver(),
-      rootType: normalizeTypes(Oas3Types).Root,
-    });
-
-    expect(Array.from(resolvedRefs.values()).pop()!.error).toBeInstanceOf(Error);
-  });
-});

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

@@ -1,11 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-
-import { isBrowser } from '../env';
-
-describe('isBrowser', () => {
-  it('should be browser', () => {
-    expect(isBrowser).toBe(true);
-  });
-});

package/src/__tests__/utils.test.ts

@@ -1,144 +0,0 @@
-import {
-  pickObjectProps,
-  omitObjectProps,
-  slash,
-  getMatchingStatusCodeRange,
-  doesYamlFileExist,
-  pickDefined,
-} from '../utils';
-import { isBrowser } from '../env';
-import * as fs from 'fs';
-import * as path from 'path';
-
-describe('utils', () => {
-  const testObject = {
-    a: 'value a',
-    b: 'value b',
-    c: 'value c',
-    d: 'value d',
-    e: 'value e',
-  };
-
-  describe('pickObjectProps', () => {
-    it('returns correct object result', () => {
-      expect(pickObjectProps(testObject, ['a', 'b'])).toStrictEqual({ a: 'value a', b: 'value b' });
-    });
-
-    it('returns correct object if passed non existing key', () => {
-      expect(pickObjectProps(testObject, ['a', 'b', 'nonExisting'])).toStrictEqual({
-        a: 'value a',
-        b: 'value b',
-      });
-    });
-
-    it('returns an empty object if no keys are passed', () => {
-      expect(pickObjectProps(testObject, [])).toStrictEqual({});
-    });
-
-    it('returns an empty object if empty target obj passed', () => {
-      expect(pickObjectProps({}, ['d', 'e'])).toStrictEqual({});
-    });
-  });
-
-  describe('omitObjectProps', () => {
-    it('returns correct object result', () => {
-      expect(omitObjectProps(testObject, ['a', 'b', 'c'])).toStrictEqual({
-        d: 'value d',
-        e: 'value e',
-      });
-    });
-
-    it('returns correct object if passed non existing key', () => {
-      expect(omitObjectProps(testObject, ['a', 'b', 'c', 'nonExisting'])).toStrictEqual({
-        d: 'value d',
-        e: 'value e',
-      });
-    });
-
-    it('returns full object if no keys are passed', () => {
-      expect(omitObjectProps(testObject, [])).toStrictEqual(testObject);
-    });
-
-    it('returns an empty object if empty target obj passed', () => {
-      expect(omitObjectProps({}, ['d', 'e'])).toStrictEqual({});
-    });
-  });
-
-  describe('slash path', () => {
-    it('can correctly slash path', () => {
-      [
-        ['foo\\bar', 'foo/bar'],
-        ['foo/bar', 'foo/bar'],
-        ['foo\\中文', 'foo/中文'],
-        ['foo/中文', 'foo/中文'],
-      ].forEach(([path, expectRes]) => {
-        expect(slash(path)).toBe(expectRes);
-      });
-    });
-
-    it('does not modify extended length paths', () => {
-      const extended = '\\\\?\\some\\path';
-      expect(slash(extended)).toBe(extended);
-    });
-  });
-
-  describe('pickDefined', () => {
-    it('returns undefined for undefined', () => {
-      expect(pickDefined(undefined)).toBeUndefined();
-    });
-
-    it('picks only defined values', () => {
-      expect(pickDefined({ a: 1, b: undefined, c: 3 })).toStrictEqual({ a: 1, c: 3 });
-    });
-  });
-
-  describe('getMatchingStatusCodeRange', () => {
-    it('should get the generalized form of status codes', () => {
-      expect(getMatchingStatusCodeRange('202')).toEqual('2XX');
-      expect(getMatchingStatusCodeRange(400)).toEqual('4XX');
-    });
-    it('should fail on a wrong input', () => {
-      expect(getMatchingStatusCodeRange('2002')).toEqual('2002');
-      expect(getMatchingStatusCodeRange(4000)).toEqual('4000');
-    });
-
-    describe('isConfigFileExist', () => {
-      beforeEach(() => {
-        jest
-          .spyOn(fs, 'existsSync')
-          .mockImplementation((path) => path === 'redocly.yaml' || path === 'redocly.yml');
-        jest.spyOn(path, 'extname').mockImplementation((path) => {
-          if (path.endsWith('.yaml')) {
-            return '.yaml';
-          } else if (path.endsWith('.yml')) {
-            return '.yml';
-          } else {
-            return '';
-          }
-        });
-      });
-
-      it('should return true because of valid path provided', () => {
-        expect(doesYamlFileExist('redocly.yaml')).toBe(true);
-      });
-
-      it('should return true because of valid path provided with yml', () => {
-        expect(doesYamlFileExist('redocly.yml')).toBe(true);
-      });
-
-      it('should return false because of fail do not exist', () => {
-        expect(doesYamlFileExist('redoccccly.yaml')).toBe(false);
-      });
-
-      it('should return false because of it is not yaml file', () => {
-        expect(doesYamlFileExist('redocly.yam')).toBe(false);
-      });
-    });
-
-    describe('isBrowser', () => {
-      it('should not be browser', () => {
-        expect(isBrowser).toBe(false);
-      });
-    });
-  });
-});