@redocly/openapi-core 1.0.0-beta.100

package/src/__tests__/normalizeVisitors.test.ts

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

@@ -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).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",
+            },
+          },
+        ],
+      ]
+    `);
+  });
+});