@redocly/openapi-core 1.0.0-beta.104 → 1.0.0-beta.107

package/src/lint.ts

@@ -1,20 +1,17 @@
 import { BaseResolver, resolveDocument, Document, makeDocumentFromString } from './resolve';
-import {
-  normalizeVisitors,
-} from './visitors';
+import { normalizeVisitors } from './visitors';
 import { Oas3_1Types } from './types/oas3_1';
 import { Oas3Types } from './types/oas3';
 import { Oas2Types } from './types/oas2';
 import { NodeType } from './types';
 import { ProblemSeverity, WalkContext, walkDocument } from './walk';
-import { LintConfig, Config, initRules, defaultPlugin, resolvePlugins } from './config';
+import { StyleguideConfig, Config, initRules, defaultPlugin, resolvePlugins } from './config';
 import { normalizeTypes } from './types';
 import { releaseAjvInstance } from './rules/ajv';
 import { detectOpenAPI, Oas3RuleSet, OasMajorVersion, OasVersion, openAPIMajor } from './oas-types';
 import { ConfigTypes } from './types/redocly-yaml';
 import { OasSpec } from './rules/common/spec';
 
-
 export async function lint(opts: {
   ref: string;
   config: Config;
@@ -27,7 +24,7 @@ export async function lint(opts: {
     document,
     ...opts,
     externalRefResolver,
-    config: opts.config.lint,
+    config: opts.config.styleguide,
   });
 }
 
@@ -44,13 +41,13 @@ export async function lintFromString(opts: {
     document,
     ...opts,
     externalRefResolver,
-    config: opts.config.lint,
+    config: opts.config.styleguide,
   });
 }
 
 export async function lintDocument(opts: {
   document: Document;
-  config: LintConfig;
+  config: StyleguideConfig;
   customTypes?: Record<string, NodeType>;
   externalRefResolver: BaseResolver;
 }) {
@@ -62,10 +59,14 @@ export async function lintDocument(opts: {
   const rules = config.getRulesForOasVersion(oasMajorVersion);
   const types = normalizeTypes(
     config.extendTypes(
-      customTypes ?? oasMajorVersion === OasMajorVersion.Version3 ? (oasVersion === OasVersion.Version3_1 ? Oas3_1Types : Oas3Types) : Oas2Types,
-      oasVersion,
+      customTypes ?? oasMajorVersion === OasMajorVersion.Version3
+        ? oasVersion === OasVersion.Version3_1
+          ? Oas3_1Types
+          : Oas3Types
+        : Oas2Types,
+      oasVersion
     ),
-    config,
+    config
   );
 
   const ctx: WalkContext = {
@@ -80,7 +81,7 @@ export async function lintDocument(opts: {
   const resolvedRefMap = await resolveDocument({
     rootDocument: document,
     rootType: types.DefinitionRoot,
-    externalRefResolver
+    externalRefResolver,
   });
 
   walkDocument({
@@ -93,10 +94,7 @@ export async function lintDocument(opts: {
   return ctx.problems.map((problem) => config.addProblemToIgnore(problem));
 }
 
-export async function lintConfig(opts: {
-  document: Document
-  severity?: ProblemSeverity 
-}) {
+export async function lintConfig(opts: { document: Document; severity?: ProblemSeverity }) {
   const { document, severity } = opts;
 
   const ctx: WalkContext = {
@@ -105,13 +103,19 @@ export async function lintConfig(opts: {
     visitorsData: {},
   };
   const plugins = resolvePlugins([defaultPlugin]);
-  const config = new LintConfig({
+  const config = new StyleguideConfig({
     plugins,
     rules: { spec: 'error' },
   });
 
   const types = normalizeTypes(ConfigTypes, config);
-  const rules = [{ severity: severity || 'error', ruleId: 'configuration spec', visitor: OasSpec({ severity: 'error' }) }];
+  const rules = [
+    {
+      severity: severity || 'error',
+      ruleId: 'configuration spec',
+      visitor: OasSpec({ severity: 'error' }),
+    },
+  ];
   const normalizedVisitors = normalizeVisitors(rules, types);
 
   walkDocument({

package/src/oas-types.ts

@@ -1,9 +1,4 @@
-import {
-  Oas3Rule,
-  Oas3Preprocessor,
-  Oas2Rule,
-  Oas2Preprocessor,
-} from './visitors';
+import { Oas3Rule, Oas3Preprocessor, Oas2Rule, Oas2Preprocessor } from './visitors';
 
 export type RuleSet<T> = Record<string, T>;
 

package/src/redocly/__tests__/redocly-client.test.ts

@@ -59,55 +59,57 @@ describe('RedoclyClient', () => {
 
   it('should resolve all tokens', async () => {
     let spy = jest.spyOn(RedoclyClient.prototype, 'readCredentialsFile').mockImplementation(() => {
-      return { token: "accessToken", us: "accessToken", eu: "eu-accessToken" };
+      return { token: 'accessToken', us: 'accessToken', eu: 'eu-accessToken' };
     });
     const client = new RedoclyClient();
     const tokens = client.getAllTokens();
     expect(tokens).toStrictEqual([
       { region: 'us', token: 'accessToken' },
-      { region: 'eu', token: 'eu-accessToken' }
+      { region: 'eu', token: 'eu-accessToken' },
     ]);
     spy.mockRestore();
   });
 
   it('should resolve valid tokens data', async () => {
     let spy = jest.spyOn(RedoclyClient.prototype, 'readCredentialsFile').mockImplementation(() => {
-      return { us: "accessToken", eu: "eu-accessToken" }
+      return { us: 'accessToken', eu: 'eu-accessToken' };
     });
     const client = new RedoclyClient();
     const tokens = await client.getValidTokens();
     expect(tokens).toStrictEqual([
       { region: 'us', token: 'accessToken', valid: true },
-      { region: 'eu', token: 'eu-accessToken', valid: true }
+      { region: 'eu', token: 'eu-accessToken', valid: true },
     ]);
     spy.mockRestore();
   });
 
   it('should not call setAccessTokens by default', () => {
-    let spy = jest.spyOn(RedoclyClient.prototype, 'readCredentialsFile').mockImplementation(() => ({}));
+    let spy = jest
+      .spyOn(RedoclyClient.prototype, 'readCredentialsFile')
+      .mockImplementation(() => ({}));
     jest.spyOn(RedoclyClient.prototype, 'setAccessTokens').mockImplementation();
     const client = new RedoclyClient();
-    expect(client.setAccessTokens).not.toHaveBeenCalled()
+    expect(client.setAccessTokens).not.toHaveBeenCalled();
     spy.mockRestore();
   });
 
   it('should set correct accessTokens - backward compatibility: default US region', () => {
-    let spy = jest.spyOn(RedoclyClient.prototype, 'readCredentialsFile').mockImplementation(() => ({ token: testToken }));
+    let spy = jest
+      .spyOn(RedoclyClient.prototype, 'readCredentialsFile')
+      .mockImplementation(() => ({ token: testToken }));
     jest.spyOn(RedoclyClient.prototype, 'setAccessTokens').mockImplementation();
     const client = new RedoclyClient();
-    expect(client.setAccessTokens).toBeCalledWith(
-      expect.objectContaining({ us: testToken })
-    );
+    expect(client.setAccessTokens).toBeCalledWith(expect.objectContaining({ us: testToken }));
     spy.mockRestore();
   });
 
   it('should set correct accessTokens - backward compatibility: EU region', () => {
-    let spy = jest.spyOn(RedoclyClient.prototype, 'readCredentialsFile').mockImplementation(() => ({ token: testToken }));
+    let spy = jest
+      .spyOn(RedoclyClient.prototype, 'readCredentialsFile')
+      .mockImplementation(() => ({ token: testToken }));
     jest.spyOn(RedoclyClient.prototype, 'setAccessTokens').mockImplementation();
     const client = new RedoclyClient('eu');
-    expect(client.setAccessTokens).toBeCalledWith(
-      expect.objectContaining({ eu: testToken })
-    );
+    expect(client.setAccessTokens).toBeCalledWith(expect.objectContaining({ eu: testToken }));
     spy.mockRestore();
   });
 
@@ -116,25 +118,29 @@ describe('RedoclyClient', () => {
     let spy = jest.spyOn(RedoclyClient.prototype, 'readCredentialsFile').mockImplementation();
     jest.spyOn(RedoclyClient.prototype, 'setAccessTokens').mockImplementation();
     const client = new RedoclyClient();
-    expect(client.setAccessTokens).toHaveBeenNthCalledWith(1, { "us": REDOCLY_AUTHORIZATION_TOKEN });
+    expect(client.setAccessTokens).toHaveBeenNthCalledWith(1, { us: REDOCLY_AUTHORIZATION_TOKEN });
     spy.mockRestore();
   });
 
   it('should set correct accessTokens prioritizing REDOCLY_AUTHORIZATION env over token in file', () => {
     process.env.REDOCLY_AUTHORIZATION = REDOCLY_AUTHORIZATION_TOKEN;
-    let spy = jest.spyOn(RedoclyClient.prototype, 'readCredentialsFile').mockImplementation(() => ({ token: testToken }));
+    let spy = jest
+      .spyOn(RedoclyClient.prototype, 'readCredentialsFile')
+      .mockImplementation(() => ({ token: testToken }));
     jest.spyOn(RedoclyClient.prototype, 'setAccessTokens').mockImplementation();
     const client = new RedoclyClient();
-    expect(client.setAccessTokens).toHaveBeenNthCalledWith(2, { "us": REDOCLY_AUTHORIZATION_TOKEN });
+    expect(client.setAccessTokens).toHaveBeenNthCalledWith(2, { us: REDOCLY_AUTHORIZATION_TOKEN });
     spy.mockRestore();
   });
 
   it('should set correct accessTokens prioritizing REDOCLY_AUTHORIZATION env over EU token', () => {
     process.env.REDOCLY_AUTHORIZATION = REDOCLY_AUTHORIZATION_TOKEN;
-    let spy = jest.spyOn(RedoclyClient.prototype, 'readCredentialsFile').mockImplementation(() => ({ us: testToken }));
+    let spy = jest
+      .spyOn(RedoclyClient.prototype, 'readCredentialsFile')
+      .mockImplementation(() => ({ us: testToken }));
     jest.spyOn(RedoclyClient.prototype, 'setAccessTokens').mockImplementation();
     const client = new RedoclyClient('eu');
-    expect(client.setAccessTokens).toHaveBeenNthCalledWith(2, { "eu": REDOCLY_AUTHORIZATION_TOKEN });
+    expect(client.setAccessTokens).toHaveBeenNthCalledWith(2, { eu: REDOCLY_AUTHORIZATION_TOKEN });
     spy.mockRestore();
   });
 });

package/src/redocly/index.ts

@@ -28,12 +28,14 @@ export class RedoclyClient {
 
   loadRegion(region?: Region) {
     if (region && !DOMAINS[region]) {
-      throw new Error(`Invalid argument: region in config file.\nGiven: ${green(region)}, choices: "us", "eu".`);
+      throw new Error(
+        `Invalid argument: region in config file.\nGiven: ${green(region)}, choices: "us", "eu".`
+      );
     }
 
     if (env.REDOCLY_DOMAIN) {
       return (AVAILABLE_REGIONS.find(
-        (region) => DOMAINS[region as Region] === env.REDOCLY_DOMAIN,
+        (region) => DOMAINS[region as Region] === env.REDOCLY_DOMAIN
       ) || DEFAULT_REGION) as Region;
     }
     return region || DEFAULT_REGION;
@@ -91,7 +93,7 @@ export class RedoclyClient {
     const allTokens = this.getAllTokens();
 
     const verifiedTokens = await Promise.allSettled(
-      allTokens.map(({ token, region }) => this.verifyToken(token, region)),
+      allTokens.map(({ token, region }) => this.verifyToken(token, region))
     );
 
     return allTokens
@@ -134,7 +136,7 @@ export class RedoclyClient {
   async verifyToken(
     accessToken: string,
     region: Region,
-    verbose: boolean = false,
+    verbose: boolean = false
   ): Promise<{ viewerId: string; organizations: string[] }> {
     return this.registryApi.authStatus(accessToken, region, verbose);
   }

package/src/redocly/registry-api.ts

@@ -31,7 +31,7 @@ export class RegistryApi {
 
     const response = await fetch(
       `${this.getBaseUrl(region)}${path}`,
-      Object.assign({}, options, { headers }),
+      Object.assign({}, options, { headers })
     );
 
     if (response.status === 401) {
@@ -49,7 +49,7 @@ export class RegistryApi {
   async authStatus(
     accessToken: string,
     region: Region,
-    verbose = false,
+    verbose = false
   ): Promise<{ viewerId: string; organizations: string[] }> {
     try {
       const response = await this.request('', { headers: { authorization: accessToken } }, region);
@@ -86,7 +86,7 @@ export class RegistryApi {
           isUpsert,
         }),
       },
-      this.region,
+      this.region
     );
 
     if (response.ok) {
@@ -106,7 +106,7 @@ export class RegistryApi {
     isUpsert,
     isPublic,
     batchId,
-    batchSize
+    batchSize,
   }: RegistryApiTypes.PushApiParams) {
     const response = await this.request(
       `/${organizationId}/${name}/${version}`,
@@ -123,10 +123,10 @@ export class RegistryApi {
           isUpsert,
           isPublic,
           batchId,
-          batchSize
+          batchSize,
         }),
       },
-      this.region,
+      this.region
     );
 
     if (response.ok) {

package/src/ref-utils.ts

@@ -18,8 +18,8 @@ export class Location {
       this.source,
       joinPointer(
         this.pointer,
-        (Array.isArray(components) ? components : [components]).map(escapePointer).join('/'),
-      ),
+        (Array.isArray(components) ? components : [components]).map(escapePointer).join('/')
+      )
     );
   }
 

package/src/resolve.ts

@@ -232,7 +232,7 @@ export async function resolveDocument(opts: {
     rootNode: any,
     rootNodeDocument: Document,
     rootNodePointer: string,
-    type: any,
+    type: any
   ) {
     const rootNodeDocAbsoluteRef = rootNodeDocument.source.absoluteRef;
 
@@ -295,7 +295,7 @@ export async function resolveDocument(opts: {
               resolvedRef.node,
               resolvedRef.document,
               resolvedRef.nodePointer!,
-              type,
+              type
             );
           }
         });
@@ -306,7 +306,7 @@ export async function resolveDocument(opts: {
     async function followRef(
       document: Document,
       ref: OasRef,
-      refStack: RefFrame,
+      refStack: RefFrame
     ): Promise<ResolvedRef> {
       if (hasRef(refStack.prev, ref)) {
         throw new Error('Self-referencing circular pointer');
@@ -316,7 +316,10 @@ export async function resolveDocument(opts: {
       let targetDoc: Document;
       try {
         targetDoc = isRemote
-          ? ((await externalRefResolver.resolveDocument(document.source.absoluteRef, uri!)) as Document)
+          ? ((await externalRefResolver.resolveDocument(
+              document.source.absoluteRef,
+              uri!
+            )) as Document)
           : document;
       } catch (error) {
         const resolvedRef = {

package/src/rules/__tests__/no-unresolved-refs.test.ts

@@ -15,7 +15,7 @@ describe('oas3 boolean-parameter-prefixes', () => {
               requestBody:
                 $ref: 'invalid.yaml'
       `,
-      path.join(__dirname, 'foobar.yaml'),
+      path.join(__dirname, 'foobar.yaml')
     );
 
     const results = await lintDocument({
@@ -55,7 +55,7 @@ describe('oas3 boolean-parameter-prefixes', () => {
               requestBody:
                 $ref: 'fixtures/invalid-yaml.yaml'
       `,
-      path.join(__dirname, 'foobar.yaml'),
+      path.join(__dirname, 'foobar.yaml')
     );
 
     const results = await lintDocument({
@@ -112,7 +112,7 @@ describe('oas3 boolean-parameter-prefixes', () => {
               requestBody:
                 $ref: 'fixtures/ref.yaml'
       `,
-      path.join(__dirname, 'foobar.yaml'),
+      path.join(__dirname, 'foobar.yaml')
     );
 
     const results = await lintDocument({
@@ -136,7 +136,7 @@ describe('oas3 boolean-parameter-prefixes', () => {
               requestBody:
                 $ref: '#/components/requestBodies/a'
       `,
-      path.join(__dirname, 'foobar.yaml'),
+      path.join(__dirname, 'foobar.yaml')
     );
 
     const results = await lintDocument({

package/src/rules/__tests__/utils.test.ts

@@ -0,0 +1,160 @@
+import {
+  fieldNonEmpty,
+  matchesJsonSchemaType,
+  missingRequiredField,
+  oasTypeOf,
+  getAdditionalPropertiesOption,
+} from '../utils';
+
+describe('field-non-empty', () => {
+  it('should match expected message', () => {
+    const message = fieldNonEmpty('Car', 'color');
+    expect(message).toBe('Car object `color` must be non-empty string.');
+  });
+});
+
+describe('matches-json-schema-type', () => {
+  it('should report true on a null value with nullable type', () => {
+    const results = matchesJsonSchemaType(null, 'string', true);
+    expect(results).toBe(true);
+  });
+
+  it('should report true on a value and type integer', () => {
+    const results = matchesJsonSchemaType(123, 'integer', false);
+    expect(results).toBe(true);
+  });
+
+  it('should report false when the value is not integer and type is integer', () => {
+    const results = matchesJsonSchemaType(3.14, 'integer', false);
+    expect(results).toBe(false);
+  });
+
+  it('should report true when the value is a number and type is number', () => {
+    const results = matchesJsonSchemaType(3.14, 'number', false);
+    expect(results).toBe(true);
+  });
+
+  it('should report true when the value is an integer and type is number', () => {
+    const results = matchesJsonSchemaType(3, 'number', false);
+    expect(results).toBe(true);
+  });
+
+  it('should report true when the value is true and type is boolean', () => {
+    const results = matchesJsonSchemaType(true, 'boolean', false);
+    expect(results).toBe(true);
+  });
+
+  it('should report true when the value is false and type is boolean', () => {
+    const results = matchesJsonSchemaType(false, 'boolean', false);
+    expect(results).toBe(true);
+  });
+
+  it('should report true when the value is a string and type is boolean', () => {
+    const results = matchesJsonSchemaType('test', 'boolean', false);
+    expect(results).toBe(false);
+  });
+
+  it('should report true on an array value with array type', () => {
+    const results = matchesJsonSchemaType(['foo', 'bar'], 'array', false);
+    expect(results).toBe(true);
+  });
+
+  it('should report false on an array value with object type', () => {
+    const results = matchesJsonSchemaType(['foo', 'bar'], 'object', false);
+    expect(results).toBe(false);
+  });
+
+  it('should report true on an object value with object type', () => {
+    const car = { type: 'Fiat', model: '500', color: 'white' };
+    const results = matchesJsonSchemaType(car, 'object', true);
+    expect(results).toBe(true);
+  });
+
+  it('should report false on an object value with array type', () => {
+    const car = { type: 'Fiat', model: '500', color: 'white' };
+    const results = matchesJsonSchemaType(car, 'array', true);
+    expect(results).toBe(false);
+  });
+});
+
+describe('missing-required-field', () => {
+  it('should match expected message for missing required field', () => {
+    const message = missingRequiredField('Car', 'color');
+    expect(message).toBe('Car object should contain `color` field.');
+  });
+});
+
+describe('oas-type-of', () => {
+  it('should report the correct oas type for a string', () => {
+    const results = oasTypeOf('word');
+    expect(results).toBe('string');
+  });
+
+  it('should report the correct oas type for an integer', () => {
+    const results = oasTypeOf(123);
+    expect(results).toBe('integer');
+  });
+
+  it('should report the correct oas type for a number', () => {
+    const results = oasTypeOf(3.14);
+    expect(results).toBe('number');
+  });
+
+  it('should report the correct oas type for a null value', () => {
+    const results = oasTypeOf(null);
+    expect(results).toBe('null');
+  });
+
+  it('should report the correct oas type for a true boolean', () => {
+    const results = oasTypeOf(true);
+    expect(results).toBe('boolean');
+  });
+
+  it('should report the correct oas type for a false boolean', () => {
+    const results = oasTypeOf(false);
+    expect(results).toBe('boolean');
+  });
+
+  it('should report the correct oas type for an array', () => {
+    const results = oasTypeOf(['foo', 'bar']);
+    expect(results).toBe('array');
+  });
+
+  it('should report the correct oas type for an object', () => {
+    const car = { type: 'Fiat', model: '500', color: 'white' };
+    const results = oasTypeOf(car);
+    expect(results).toBe('object');
+  });
+});
+
+describe('get-additional-properties-option', () => {
+  it('should return actual option', () => {
+    const options = {
+      allowAdditionalProperties: true,
+    };
+    expect(getAdditionalPropertiesOption(options)).toBeTruthy();
+  });
+
+  it('should reverse option', () => {
+    const options = {
+      disallowAdditionalProperties: true,
+    };
+    expect(getAdditionalPropertiesOption(options)).toBeFalsy();
+  });
+
+  it('should throw error with message', () => {
+    const options = {
+      allowAdditionalProperties: true,
+      disallowAdditionalProperties: false,
+    };
+
+    try {
+      getAdditionalPropertiesOption(options);
+    } catch (error) {
+      expect(error).toBeInstanceOf(Error);
+      expect(error.message).toEqual(
+        "Do not use 'disallowAdditionalProperties' field. Use 'allowAdditionalProperties' instead.\n"
+      );
+    }
+  });
+});

package/src/rules/ajv.ts

@@ -8,7 +8,7 @@ export function releaseAjvInstance() {
   ajvInstance = null;
 }
 
-function getAjv(resolve: ResolveFn, disallowAdditionalProperties: boolean) {
+function getAjv(resolve: ResolveFn, allowAdditionalProperties: boolean) {
   if (!ajvInstance) {
     ajvInstance = new Ajv({
       schemaId: '$id',
@@ -20,7 +20,7 @@ function getAjv(resolve: ResolveFn, disallowAdditionalProperties: boolean) {
       discriminator: true,
       allowUnionTypes: true,
       validateFormats: false, // TODO: fix it
-      defaultAdditionalProperties: !disallowAdditionalProperties,
+      defaultAdditionalProperties: allowAdditionalProperties,
       loadSchemaSync(base: string, $ref: string) {
         const resolvedRef = resolve({ $ref }, base.split('#')[0]);
         if (!resolvedRef || !resolvedRef.location) return false;
@@ -36,9 +36,9 @@ function getAjvValidator(
   schema: any,
   loc: Location,
   resolve: ResolveFn,
-  disallowAdditionalProperties: boolean,
+  allowAdditionalProperties: boolean
 ): ValidateFunction | undefined {
-  const ajv = getAjv(resolve, disallowAdditionalProperties);
+  const ajv = getAjv(resolve, allowAdditionalProperties);
 
   if (!ajv.getSchema(loc.absolutePointer)) {
     ajv.addSchema({ $id: loc.absolutePointer, ...schema }, loc.absolutePointer);
@@ -53,9 +53,9 @@ export function validateJsonSchema(
   schemaLoc: Location,
   instancePath: string,
   resolve: ResolveFn,
-  disallowAdditionalProperties: boolean,
+  allowAdditionalProperties: boolean
 ): { valid: boolean; errors: (ErrorObject & { suggest?: string[] })[] } {
-  const validate = getAjvValidator(schema, schemaLoc, resolve, disallowAdditionalProperties);
+  const validate = getAjvValidator(schema, schemaLoc, resolve, allowAdditionalProperties);
   if (!validate) return { valid: true, errors: [] }; // unresolved refs are reported
 
   const valid = validate(data, {
@@ -73,8 +73,7 @@ export function validateJsonSchema(
 
   function beatifyErrorMessage(error: ErrorObject) {
     let message = error.message;
-    let suggest =
-      error.keyword === 'enum' ? error.params.allowedValues : undefined;
+    let suggest = error.keyword === 'enum' ? error.params.allowedValues : undefined;
     if (suggest) {
       message += ` ${suggest.map((e: any) => `"${e}"`).join(', ')}`;
     }

package/src/rules/common/__tests__/info-description.test.ts

@@ -11,7 +11,7 @@ describe('Oas3 info-description', () => {
           info:
             version: '1.0'
         `,
-      'foobar.yaml',
+      'foobar.yaml'
     );
 
     const results = await lintDocument({
@@ -49,7 +49,7 @@ describe('Oas3 info-description', () => {
             version: '1.0'
             description: ''
         `,
-      'foobar.yaml',
+      'foobar.yaml'
     );
 
     const results = await lintDocument({
@@ -86,7 +86,7 @@ describe('Oas3 info-description', () => {
           info:
             description: test description
         `,
-      'foobar.yaml',
+      'foobar.yaml'
     );
 
     const results = await lintDocument({

package/src/rules/common/__tests__/info-license.test.ts

@@ -11,7 +11,7 @@ describe('Oas3 info-license', () => {
           info:
             version: '1.0'
         `,
-      'foobar.yaml',
+      'foobar.yaml'
     );
 
     const results = await lintDocument({
@@ -48,7 +48,7 @@ describe('Oas3 info-license', () => {
               name: MIT
               url: google.com
         `,
-      'foobar.yaml',
+      'foobar.yaml'
     );
 
     const results = await lintDocument({

package/src/rules/common/__tests__/license-url.test.ts

@@ -12,7 +12,7 @@ describe('Oas3 license-url', () => {
             license:
               name: MIT
         `,
-      'foobar.yaml',
+      'foobar.yaml'
     );
 
     const results = await lintDocument({
@@ -49,7 +49,7 @@ describe('Oas3 license-url', () => {
               name: MIT
               url: google.com
         `,
-      'foobar.yaml',
+      'foobar.yaml'
     );
 
     const results = await lintDocument({

package/src/rules/common/__tests__/no-ambiguous-paths.test.ts

@@ -40,7 +40,7 @@ describe('no-ambiguous-paths', () => {
             get:
               summary: List all pets
         `,
-      'foobar.yaml',
+      'foobar.yaml'
     );
 
     const results = await lintDocument({