@redocly/openapi-core 1.0.0-beta.99 → 1.0.0-rc.2

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

@@ -1,120 +0,0 @@
-import outdent from 'outdent';
-import { parseYamlToDocument } from '../../__tests__/utils';
-import { parseRef, refBaseName } from '../ref-utils';
-import { lintDocument } from '../lint';
-import { LintConfig } 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(`
-      Object {
-        "pointer": Array [
-          "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(`
-      Object {
-        "pointer": Array [
-          "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(`
-      Object {
-        "pointer": Array [
-          "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 LintConfig({}),
-    });
-
-    expect(result).toMatchInlineSnapshot(`Array []`);
-  });
-
-  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).DefinitionRoot,
-    });
-
-    expect(fetchMock).toBeCalledTimes(3);
-    expect(fetchMock.mock.calls).toMatchInlineSnapshot(`
-      Array [
-        Array [
-          "https://example.com/test.yaml",
-          Object {
-            "headers": Object {
-              "X_TEST": "123",
-            },
-          },
-        ],
-        Array [
-          "https://sample.com/test.yaml",
-          Object {
-            "headers": Object {},
-          },
-        ],
-        Array [
-          "https://sample.com/test/a/test.yaml",
-          Object {
-            "headers": Object {
-              "X_TEST": "321",
-            },
-          },
-        ],
-      ]
-    `);
-  });
-});

package/src/__tests__/resolve.test.ts

@@ -1,405 +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';
-
-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).DefinitionRoot,
-    });
-
-    expect(resolvedRefs).toBeDefined();
-    expect(resolvedRefs.size).toEqual(1);
-    expect(Array.from(resolvedRefs.keys())).toMatchInlineSnapshot(
-      [`foobar.yaml::#/defs/info`],
-      `
-      Array [
-        "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).DefinitionRoot,
-      });
-    } 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).DefinitionRoot,
-    });
-
-    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).DefinitionRoot,
-      });
-    } 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).DefinitionRoot,
-    });
-
-    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).DefinitionRoot,
-    });
-
-    expect(resolvedRefs).toBeDefined();
-
-    expect(Array.from(resolvedRefs.keys()).map((ref) => ref.substring(cwd.length + 1)).sort())
-      .toMatchInlineSnapshot(`
-      Array [
-        "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(`
-      Array [
-        Object {
-          "allOf": Array [
-            Object {
-              "properties": Object {
-                "integration_type": Object {
-                  "$ref": "../openapi-with-back.yaml#/components/schemas/TypeB",
-                },
-                "name": Object {
-                  "type": "string",
-                },
-              },
-              "required": Array [
-                "name",
-                "integration_type",
-              ],
-              "type": "object",
-            },
-          ],
-        },
-        Object {
-          "enum": Array [
-            "webhook",
-            "api_key",
-            "sftp",
-            "netsuite",
-          ],
-          "type": "string",
-        },
-        Object {
-          "enum": Array [
-            "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).DefinitionRoot,
-    });
-
-    expect(resolvedRefs).toBeDefined();
-    expect(Array.from(resolvedRefs.keys()).map((ref) => ref.substring(cwd.length + 1)))
-      .toMatchInlineSnapshot(`
-      Array [
-        "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(`
-      Array [
-        Object {
-          "properties": Object {
-            "localCircular": Object {
-              "$ref": "#/components/schemas/Local",
-            },
-            "number": Object {
-              "type": "number",
-            },
-            "string": Object {
-              "type": "string",
-            },
-          },
-        },
-        Object {
-          "type": "string",
-        },
-        Object {
-          "type": "string",
-        },
-        Object {
-          "properties": Object {
-            "external": Object {
-              "$ref": "./External2.yaml",
-            },
-            "number": Object {
-              "type": "number",
-            },
-            "string": Object {
-              "type": "string",
-            },
-            "unknown": Object {
-              "type": "string",
-            },
-          },
-          "type": "object",
-        },
-        Object {
-          "properties": Object {
-            "circularParent": Object {
-              "$ref": "./External.yaml#/properties",
-            },
-          },
-          "type": "object",
-        },
-        Object {
-          "external": Object {
-            "$ref": "./External2.yaml",
-          },
-          "number": Object {
-            "type": "number",
-          },
-          "string": Object {
-            "type": "string",
-          },
-          "unknown": Object {
-            "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).DefinitionRoot,
-    });
-
-    expect(resolvedRefs).toBeDefined();
-    // expect(resolvedRefs.size).toEqual(2);
-    expect(Array.from(resolvedRefs.keys()).map((ref) => ref.substring(cwd.length + 1)))
-      .toMatchInlineSnapshot(`
-      Array [
-        "openapi-with-md-description.yaml::./description.md",
-      ]
-    `);
-    expect(Array.from(resolvedRefs.values()).map((val) => val.node)).toMatchInlineSnapshot(`
-      Array [
-        "# 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).DefinitionRoot,
-    });
-
-    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' });
-  });
-});

package/src/__tests__/utils.test.ts

@@ -1,85 +0,0 @@
-import { pickObjectProps, omitObjectProps, slash, getMatchingStatusCodeRange } from '../utils';
-
-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('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');
-    });
-  });
-});