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

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

@@ -0,0 +1,120 @@
+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(`
+      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 StyleguideConfig({}),
+    });
+
+    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

@@ -0,0 +1,77 @@
+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(`
+      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

@@ -0,0 +1,431 @@
+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`],
+      `
+      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).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(`
+      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).Root,
+    });
+
+    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).Root,
+    });
+
+    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).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

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