@redocly/openapi-core 1.0.0-beta.67 → 1.0.0-beta.71

package/lib/rules/oas3/no-invalid-media-type-examples.js

@@ -1,18 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValidContentExamples = void 0;
-const ajv_1 = require("../ajv");
 const ref_utils_1 = require("../../ref-utils");
+const utils_1 = require("../utils");
 const ValidContentExamples = (opts) => {
     var _a;
     const disallowAdditionalProperties = (_a = opts.disallowAdditionalProperties) !== null && _a !== void 0 ? _a : true;
     return {
         MediaType: {
-            leave(mediaType, { report, location, resolve }) {
+            leave(mediaType, ctx) {
+                const { location, resolve } = ctx;
                 if (!mediaType.schema)
                     return;
                 if (mediaType.example) {
-                    validateExample(mediaType.example, location.child('example'));
+                    utils_1.validateExample(mediaType.example, mediaType.schema, location.child('example'), ctx, disallowAdditionalProperties);
                 }
                 else if (mediaType.examples) {
                     for (const exampleName of Object.keys(mediaType.examples)) {
@@ -25,29 +26,7 @@ const ValidContentExamples = (opts) => {
                             dataLoc = resolved.location.child('value');
                             example = resolved.node;
                         }
-                        validateExample(example.value, dataLoc);
-                    }
-                }
-                function validateExample(example, dataLoc) {
-                    try {
-                        const { valid, errors } = ajv_1.validateJsonSchema(example, mediaType.schema, location.child('schema'), dataLoc.pointer, resolve, disallowAdditionalProperties);
-                        if (!valid) {
-                            for (let error of errors) {
-                                report({
-                                    message: `Example value must conform to the schema: ${error.message}.`,
-                                    location: Object.assign(Object.assign({}, new ref_utils_1.Location(dataLoc.source, error.instancePath)), { reportOnKey: error.keyword === 'additionalProperties' }),
-                                    from: location,
-                                    suggest: error.suggest,
-                                });
-                            }
-                        }
-                    }
-                    catch (e) {
-                        report({
-                            message: `Example validation errored: ${e.message}.`,
-                            location: location.child('schema'),
-                            from: location
-                        });
+                        utils_1.validateExample(example.value, mediaType.schema, dataLoc, ctx, disallowAdditionalProperties);
                     }
                 }
             },

package/lib/rules/oas3/no-server-trailing-slash.js

@@ -6,7 +6,7 @@ const NoServerTrailingSlash = () => {
         Server(server, { report, location }) {
             if (!server.url)
                 return;
-            if (server.url.endsWith('/')) {
+            if (server.url.endsWith('/') && server.url !== '/') {
                 report({
                     message: 'Server `url` should not have a trailing slash.',
                     location: location.child(['url']),

package/lib/rules/utils.d.ts

@@ -1,4 +1,6 @@
 import { UserContext } from '../walk';
+import { Location } from '../ref-utils';
+import { Oas3Schema, Referenced } from '../typings/openapi';
 export declare function oasTypeOf(value: unknown): "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" | "array" | "null";
 /**
  * Checks if value matches specified JSON schema type
@@ -12,3 +14,4 @@ export declare function missingRequiredField(type: string, field: string): strin
 export declare function fieldNonEmpty(type: string, field: string): string;
 export declare function validateDefinedAndNonEmpty(fieldName: string, value: any, ctx: UserContext): void;
 export declare function getSuggest(given: string, variants: string[]): string[];
+export declare function validateExample(example: any, schema: Referenced<Oas3Schema>, dataLoc: Location, { resolve, location, report }: UserContext, disallowAdditionalProperties: boolean): void;

package/lib/rules/utils.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSuggest = exports.validateDefinedAndNonEmpty = exports.fieldNonEmpty = exports.missingRequiredField = exports.matchesJsonSchemaType = exports.oasTypeOf = void 0;
+exports.validateExample = exports.getSuggest = exports.validateDefinedAndNonEmpty = exports.fieldNonEmpty = exports.missingRequiredField = exports.matchesJsonSchemaType = exports.oasTypeOf = void 0;
 const levenshtein = require("js-levenshtein");
+const ref_utils_1 = require("../ref-utils");
+const ajv_1 = require("./ajv");
 function oasTypeOf(value) {
     if (Array.isArray(value)) {
         return 'array';
@@ -80,3 +82,26 @@ function getSuggest(given, variants) {
     return distances.map((d) => d.variant);
 }
 exports.getSuggest = getSuggest;
+function validateExample(example, schema, dataLoc, { resolve, location, report }, disallowAdditionalProperties) {
+    try {
+        const { valid, errors } = ajv_1.validateJsonSchema(example, schema, location.child('schema'), dataLoc.pointer, resolve, disallowAdditionalProperties);
+        if (!valid) {
+            for (let error of errors) {
+                report({
+                    message: `Example value must conform to the schema: ${error.message}.`,
+                    location: Object.assign(Object.assign({}, new ref_utils_1.Location(dataLoc.source, error.instancePath)), { reportOnKey: error.keyword === 'additionalProperties' }),
+                    from: location,
+                    suggest: error.suggest,
+                });
+            }
+        }
+    }
+    catch (e) {
+        report({
+            message: `Example validation errored: ${e.message}.`,
+            location: location.child('schema'),
+            from: location,
+        });
+    }
+}
+exports.validateExample = validateExample;

package/lib/typings/openapi.d.ts

@@ -144,6 +144,9 @@ export interface Oas3Schema {
     example?: any;
     xml?: Oas3Xml;
 }
+export interface Oas3_1Schema extends Oas3Schema {
+    examples?: any[];
+}
 export interface Oas3Discriminator {
     propertyName: string;
     mapping?: {

package/lib/utils.d.ts

@@ -33,3 +33,4 @@ export declare function isPathParameter(pathSegment: string): boolean;
  * Convert Windows backslash paths to slash paths: foo\\bar ➔ foo/bar
  */
 export declare function slash(path: string): string;
+export declare function isNotEmptyObject(obj: any): boolean;

package/lib/utils.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.slash = exports.isPathParameter = exports.readFileAsStringSync = exports.isSingular = exports.validateMimeTypeOAS3 = exports.validateMimeType = exports.splitCamelCaseIntoWords = exports.omitObjectProps = exports.pickObjectProps = exports.match = exports.readFileFromUrl = exports.isPlainObject = exports.notUndefined = exports.loadYaml = exports.popStack = exports.pushStack = exports.stringifyYaml = exports.parseYaml = void 0;
+exports.isNotEmptyObject = exports.slash = exports.isPathParameter = exports.readFileAsStringSync = exports.isSingular = exports.validateMimeTypeOAS3 = exports.validateMimeType = exports.splitCamelCaseIntoWords = exports.omitObjectProps = exports.pickObjectProps = exports.match = exports.readFileFromUrl = exports.isPlainObject = exports.notUndefined = exports.loadYaml = exports.popStack = exports.pushStack = exports.stringifyYaml = exports.parseYaml = void 0;
 const fs = require("fs");
 const minimatch = require("minimatch");
 const node_fetch_1 = require("node-fetch");
@@ -144,3 +144,7 @@ function slash(path) {
     return path.replace(/\\/g, '/');
 }
 exports.slash = slash;
+function isNotEmptyObject(obj) {
+    return !!obj && Object.keys(obj).length > 0;
+}
+exports.isNotEmptyObject = isNotEmptyObject;

package/lib/walk.d.ts

@@ -36,6 +36,7 @@ export declare type UserContext = {
     key: string | number;
     parent: any;
     oasVersion: OasVersion;
+    getVisitorData: () => Record<string, unknown>;
 };
 export declare type Loc = {
     line: number;
@@ -72,6 +73,7 @@ export declare type NormalizedProblem = {
 export declare type WalkContext = {
     problems: NormalizedProblem[];
     oasVersion: OasVersion;
+    visitorsData: Record<string, Record<string, unknown>>;
     refTypes?: Map<string, NormalizedNodeType>;
 };
 export declare function walkDocument<T>(opts: {

package/lib/walk.js

@@ -50,6 +50,7 @@ function walkDocument(opts) {
                         key,
                         parentLocations: {},
                         oasVersion: ctx.oasVersion,
+                        getVisitorData: getVisitorDataFn.bind(undefined, ruleId)
                     }, { node: resolvedNode, location: resolvedLocation, error });
                     if ((resolvedLocation === null || resolvedLocation === void 0 ? void 0 : resolvedLocation.source.absoluteRef) && ctx.refTypes) {
                         ctx.refTypes.set(resolvedLocation === null || resolvedLocation === void 0 ? void 0 : resolvedLocation.source.absoluteRef, type);
@@ -192,6 +193,7 @@ function walkDocument(opts) {
                         key,
                         parentLocations: {},
                         oasVersion: ctx.oasVersion,
+                        getVisitorData: getVisitorDataFn.bind(undefined, ruleId)
                     }, { node: resolvedNode, location: resolvedLocation, error });
                 }
             }
@@ -212,6 +214,7 @@ function walkDocument(opts) {
                 ignoreNextVisitorsOnNode: () => {
                     ignoreNextVisitorsOnNode = true;
                 },
+                getVisitorData: getVisitorDataFn.bind(undefined, ruleId),
             }, collectParents(context), context);
             return ignoreNextVisitorsOnNode;
         }
@@ -244,6 +247,10 @@ function walkDocument(opts) {
                     return Object.assign(Object.assign(Object.assign({}, currentLocation), { reportOnKey: false }), loc);
                 }) }));
         }
+        function getVisitorDataFn(ruleId) {
+            ctx.visitorsData[ruleId] = ctx.visitorsData[ruleId] || {};
+            return ctx.visitorsData[ruleId];
+        }
     }
 }
 exports.walkDocument = walkDocument;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redocly/openapi-core",
-  "version": "1.0.0-beta.67",
+  "version": "1.0.0-beta.71",
   "description": "",
   "main": "lib/index.js",
   "engines": {

package/src/bundle.ts

@@ -7,12 +7,13 @@ import { Oas3_1Types } from './types/oas3_1';
 import { NormalizedNodeType, normalizeTypes, NodeType } from './types';
 import { WalkContext, walkDocument, UserContext, ResolveResult } from './walk';
 import { detectOpenAPI, openAPIMajor, OasMajorVersion } from './oas-types';
-import { Location, refBaseName } from './ref-utils';
+import { isRef, Location, refBaseName } from './ref-utils';
 import type { Config, LintConfig } from './config/config';
 import { initRules } from './config/rules';
 import { reportUnresolvedRef } from './rules/no-unresolved-refs';
 import { isPlainObject } from './utils';
 import { OasRef } from './typings/openapi';
+import { isRedoclyRegistryURL } from './redocly';
 
 export type Oas3RuleSet = Record<string, Oas3Rule>;
 
@@ -29,6 +30,7 @@ export async function bundle(opts: {
   config: Config;
   dereference?: boolean;
   base?: string;
+  skipRedoclyRegistryRefs?: boolean;
 }) {
   const {
     ref,
@@ -40,7 +42,8 @@ export async function bundle(opts: {
     throw new Error('Document or reference is required.\n');
   }
 
-  const document = doc !== undefined ? doc : await externalRefResolver.resolveDocument(base, ref!, true);
+  const document =
+    doc !== undefined ? doc : await externalRefResolver.resolveDocument(base, ref!, true);
 
   if (document instanceof Error) {
     throw document;
@@ -62,14 +65,26 @@ export async function bundleDocument(opts: {
   customTypes?: Record<string, NodeType>;
   externalRefResolver: BaseResolver;
   dereference?: boolean;
+  skipRedoclyRegistryRefs?: boolean;
 }) {
-  const { document, config, customTypes, externalRefResolver, dereference = false } = opts;
+  const {
+    document,
+    config,
+    customTypes,
+    externalRefResolver,
+    dereference = false,
+    skipRedoclyRegistryRefs = false,
+  } = opts;
   const oasVersion = detectOpenAPI(document.parsed);
   const oasMajorVersion = openAPIMajor(oasVersion);
   const rules = config.getRulesForOasVersion(oasMajorVersion);
   const types = normalizeTypes(
     config.extendTypes(
-      customTypes ?? oasMajorVersion === OasMajorVersion.Version3 ? (oasVersion === OasVersion.Version3_1 ? Oas3_1Types : Oas3Types) : Oas2Types,
+      customTypes ?? oasMajorVersion === OasMajorVersion.Version3
+        ? oasVersion === OasVersion.Version3_1
+          ? Oas3_1Types
+          : Oas3Types
+        : Oas2Types,
       oasVersion,
     ),
     config,
@@ -81,6 +96,7 @@ export async function bundleDocument(opts: {
     problems: [],
     oasVersion: oasVersion,
     refTypes: new Map<string, NormalizedNodeType>(),
+    visitorsData: {},
   };
 
   const bundleVisitor = normalizeVisitors(
@@ -89,7 +105,7 @@ export async function bundleDocument(opts: {
       {
         severity: 'error',
         ruleId: 'bundler',
-        visitor: makeBundleVisitor(oasMajorVersion, dereference, document),
+        visitor: makeBundleVisitor(oasMajorVersion, dereference, skipRedoclyRegistryRefs, document),
       },
       ...decorators,
     ],
@@ -116,6 +132,7 @@ export async function bundleDocument(opts: {
     fileDependencies: externalRefResolver.getFiles(),
     rootType: types.DefinitionRoot,
     refTypes: ctx.refTypes,
+    visitorsData: ctx.visitorsData,
   };
 }
 
@@ -160,7 +177,12 @@ function mapTypeToComponent(typeName: string, version: OasMajorVersion) {
 
 // function oas3Move
 
-function makeBundleVisitor(version: OasMajorVersion, dereference: boolean, rootDocument: Document) {
+function makeBundleVisitor(
+  version: OasMajorVersion,
+  dereference: boolean,
+  skipRedoclyRegistryRefs: boolean,
+  rootDocument: Document,
+) {
   let components: Record<string, Record<string, any>>;
 
   const visitor: Oas3Visitor | Oas2Visitor = {
@@ -178,6 +200,11 @@ function makeBundleVisitor(version: OasMajorVersion, dereference: boolean, rootD
         ) {
           return;
         }
+
+        if (skipRedoclyRegistryRefs && isRedoclyRegistryURL(node.$ref)) {
+          return;
+        }
+
         const componentType = mapTypeToComponent(ctx.type.name, version);
         if (!componentType) {
           replaceRef(node, resolved, ctx);
@@ -249,6 +276,21 @@ function makeBundleVisitor(version: OasMajorVersion, dereference: boolean, rootD
     }
   }
 
+  function isEqualOrEqualRef(
+    node: any,
+    target: { node: any; location: Location },
+    ctx: UserContext,
+  ) {
+    if (
+      isRef(node) &&
+      ctx.resolve(node).location?.absolutePointer === target.location.absolutePointer
+    ) {
+      return true;
+    }
+
+    return isEqual(node, target.node);
+  }
+
   function getComponentName(
     target: { node: any; location: Location },
     componentType: string,
@@ -265,20 +307,20 @@ function makeBundleVisitor(version: OasMajorVersion, dereference: boolean, rootD
       if (
         !componentsGroup ||
         !componentsGroup[name] ||
-        isEqual(componentsGroup[name], target.node)
+        isEqualOrEqualRef(componentsGroup[name], target, ctx)
       ) {
         return name;
       }
     }
 
     name = refBaseName(fileRef) + (name ? `_${name}` : '');
-    if (!componentsGroup[name] || isEqual(componentsGroup[name], target.node)) {
+    if (!componentsGroup[name] || isEqualOrEqualRef(componentsGroup[name], target, ctx)) {
       return name;
     }
 
     const prevName = name;
     let serialId = 2;
-    while (componentsGroup[name] && !isEqual(componentsGroup[name], target.node)) {
+    while (componentsGroup[name] && !isEqualOrEqualRef(componentsGroup[name], target, ctx)) {
       name = `${prevName}-${serialId}`;
       serialId++;
     }

package/src/config/__tests__/load.test.ts

@@ -0,0 +1,35 @@
+import { loadConfig } from '../load';
+import { RedoclyClient } from '../../redocly';
+
+describe('loadConfig', () => {
+  it('should resolve config http header by US region', async () => {
+    jest.spyOn(RedoclyClient.prototype, 'getTokens').mockImplementation(
+      () => Promise.resolve([{ region: 'us', token: "accessToken", valid: true }])
+    );
+    const config = await loadConfig();
+    expect(config.resolve.http.headers).toStrictEqual([{
+      "matches": 'https://api.redoc.ly/registry/**',
+      "name": "Authorization",
+      "envVariable": undefined,
+      "value": "accessToken"
+    }, {
+      "matches": 'https://api.redocly.com/registry/**',
+      "name": "Authorization",
+      "envVariable": undefined,
+      "value": "accessToken"
+    }]);
+  });
+
+  it('should resolve config http header by EU region', async () => {
+    jest.spyOn(RedoclyClient.prototype, 'getTokens').mockImplementation(
+      () => Promise.resolve([{ region: 'eu', token: "accessToken", valid: true }])
+    );
+    const config = await loadConfig();
+    expect(config.resolve.http.headers).toStrictEqual([{
+      "matches": 'https://api.eu.redocly.com/registry/**',
+      "name": "Authorization",
+      "envVariable": undefined,
+      "value": "accessToken"
+    }]);
+  });
+});

package/src/config/all.ts

@@ -38,6 +38,8 @@ export default {
     },
     'request-mime-type': 'error',
     spec: 'error',
+    'no-invalid-schema-examples': 'error',
+    'no-invalid-parameter-examples': 'error',
   },
   oas3_0Rules: {
     'no-invalid-media-type-examples': 'error',

package/src/config/config.ts

@@ -123,11 +123,20 @@ export type ResolveConfig = {
   http: HttpResolveConfig;
 };
 
+export const DEFAULT_REGION = 'us';
+export type Region = 'us' | 'eu';
+export type AccessTokens = {[region in Region]?: string };
+export const DOMAINS: { [region in Region]: string } = {
+  us: 'redoc.ly',
+  eu: 'eu.redocly.com',
+};
+
 export type RawConfig = {
   referenceDocs?: any;
   apiDefinitions?: Record<string, string>;
   lint?: LintRawConfig;
   resolve?: RawResolveConfig;
+  region?: Region;
 };
 
 export class LintConfig {
@@ -385,6 +394,7 @@ export class Config {
   lint: LintConfig;
   resolve: ResolveConfig;
   licenseKey?: string;
+  region?: Region;
   constructor(public rawConfig: RawConfig, public configFile?: string) {
     this.apiDefinitions = rawConfig.apiDefinitions || {};
     this.lint = new LintConfig(rawConfig.lint || {}, configFile);
@@ -395,6 +405,7 @@ export class Config {
         customFetch: undefined,
       },
     };
+    this.region = rawConfig.region;
   }
 }
 

package/src/config/load.ts

@@ -1,8 +1,7 @@
 import * as fs from 'fs';
-
 import { RedoclyClient } from '../redocly';
 import { loadYaml } from '../utils';
-import { Config, RawConfig } from './config';
+import { Config, DOMAINS, RawConfig, Region } from './config';
 
 import { defaultPlugin } from './builtIn';
 
@@ -25,19 +24,31 @@ export async function loadConfig(configPath?: string, customExtends?: string[]):
   }
 
   const redoclyClient = new RedoclyClient();
-  if (redoclyClient.hasToken()) {
+  const tokens = await redoclyClient.getTokens();
+
+  if (tokens.length) {
     if (!rawConfig.resolve) rawConfig.resolve = {};
     if (!rawConfig.resolve.http) rawConfig.resolve.http = {};
-    rawConfig.resolve.http.headers = [
-      {
-        matches: `https://api.${process.env.REDOCLY_DOMAIN || 'redoc.ly'}/registry/**`,
+    rawConfig.resolve.http.headers = [...(rawConfig.resolve.http.headers ?? [])];
+
+    for (const item of tokens) {
+      const domain = DOMAINS[item.region as Region];
+      rawConfig.resolve.http.headers.push({
+        matches: `https://api.${domain}/registry/**`,
         name: 'Authorization',
         envVariable: undefined,
-        value: (redoclyClient && (await redoclyClient.getAuthorizationHeader())) || '',
+        value: item.token,
       },
-      ...(rawConfig.resolve.http.headers ?? []),
-    ];
+      //support redocly.com domain for future compatibility
+      ...(item.region === 'us' ? [{
+        matches: `https://api.redocly.com/registry/**`,
+        name: 'Authorization',
+        envVariable: undefined,
+        value: item.token,
+      }] : []));
+    }
   }
+
   return new Config(
     {
       ...rawConfig,

package/src/index.ts

@@ -17,7 +17,7 @@ export { StatsAccumulator, StatsName } from './typings/common';
 export { normalizeTypes } from './types';
 export { Stats } from './rules/other/stats';
 
-export { Config, LintConfig, RawConfig, IGNORE_FILE } from './config/config';
+export { Config, LintConfig, RawConfig, IGNORE_FILE, Region } from './config/config';
 export { loadConfig } from './config/load';
 export { RedoclyClient } from './redocly';
 export {
@@ -46,11 +46,5 @@ export {
 
 export { getAstNodeByPointer, getLineColLocation } from './format/codeframes';
 export { formatProblems, OutputFormat, getTotals, Totals } from './format/format';
-export {
-  lint,
-  lint as validate,
-  lintDocument,
-  lintFromString,
-  lintConfig,
-} from './lint';
+export { lint, lint as validate, lintDocument, lintFromString, lintConfig } from './lint';
 export { bundle, bundleDocument } from './bundle';

package/src/lint.ts

@@ -72,6 +72,7 @@ export async function lintDocument(opts: {
   const ctx: WalkContext = {
     problems: [],
     oasVersion: oasVersion,
+    visitorsData: {},
   };
 
   const preprocessors = initRules(rules as any, config, 'preprocessors', oasVersion);
@@ -101,6 +102,7 @@ export async function lintConfig(opts: {
   const ctx: WalkContext = {
     problems: [],
     oasVersion: OasVersion.Version3_0,
+    visitorsData: {},
   };
   const config = new LintConfig({
     plugins: [defaultPlugin],

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

@@ -0,0 +1,120 @@
+import { RedoclyClient } from '../index';
+
+describe('RedoclyClient', () => {
+  const REDOCLY_DOMAIN_US = 'redoc.ly';
+  const REDOCLY_DOMAIN_EU = 'eu.redocly.com';
+  const REDOCLY_AUTHORIZATION_TOKEN = 'redocly-auth-token';
+  const testRedoclyDomain = 'redoclyDomain.com';
+  const testToken = 'test-token';
+
+  afterEach(() => {
+    delete process.env.REDOCLY_DOMAIN;
+  });
+
+  it('should resolve the US domain by default', () => {
+    const client = new RedoclyClient();
+    expect(client.domain).toBe(REDOCLY_DOMAIN_US);
+  });
+
+  it('should resolve domain from RedoclyDomain env', () => {
+    process.env.REDOCLY_DOMAIN = testRedoclyDomain;
+    const client = new RedoclyClient();
+    expect(client.domain).toBe(testRedoclyDomain);
+  });
+
+  it('should resolve a domain by US region', () => {
+    const client = new RedoclyClient('us');
+    expect(client.domain).toBe(REDOCLY_DOMAIN_US);
+  });
+
+  it('should resolve a domain by EU region', () => {
+    const client = new RedoclyClient('eu');
+    expect(client.domain).toBe(REDOCLY_DOMAIN_EU);
+  });
+
+  it('should resolve domain by EU region prioritizing flag over env variable', () => {
+    process.env.REDOCLY_DOMAIN = testRedoclyDomain;
+    const client = new RedoclyClient('eu');
+    expect(client.domain).toBe(REDOCLY_DOMAIN_EU);
+  });
+
+  it('should resolve domain by US region prioritizing flag over env variable', () => {
+    process.env.REDOCLY_DOMAIN = testRedoclyDomain;
+    const client = new RedoclyClient('us');
+    expect(client.domain).toBe(REDOCLY_DOMAIN_US);
+  });
+
+  it('should resolve domain by US region when REDOCLY_DOMAIN consists EU domain', () => {
+    process.env.REDOCLY_DOMAIN = REDOCLY_DOMAIN_EU;
+    const client = new RedoclyClient();
+    expect(client.getRegion()).toBe('eu');
+  });
+
+  it('should resolve valid tokens data', async () => {
+    let spy = jest.spyOn(RedoclyClient.prototype, 'readCredentialsFile').mockImplementation(() => {
+      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 }
+    ]);
+    spy.mockRestore();
+  });
+
+  it('should not call setAccessTokens by default', () => {
+    let spy = jest.spyOn(RedoclyClient.prototype, 'readCredentialsFile').mockImplementation(() => ({}));
+    jest.spyOn(RedoclyClient.prototype, 'setAccessTokens').mockImplementation();
+    const client = new RedoclyClient();
+    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 }));
+    jest.spyOn(RedoclyClient.prototype, 'setAccessTokens').mockImplementation();
+    const client = new RedoclyClient();
+    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 }));
+    jest.spyOn(RedoclyClient.prototype, 'setAccessTokens').mockImplementation();
+    const client = new RedoclyClient('eu');
+    expect(client.setAccessTokens).toBeCalledWith(
+      expect.objectContaining({ eu: testToken })
+    );
+    spy.mockRestore();
+  });
+
+  it('should set correct accessTokens - REDOCLY_AUTHORIZATION env', () => {
+    process.env.REDOCLY_AUTHORIZATION = REDOCLY_AUTHORIZATION_TOKEN;
+    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 });
+    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 }));
+    jest.spyOn(RedoclyClient.prototype, 'setAccessTokens').mockImplementation();
+    const client = new RedoclyClient();
+    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 }));
+    jest.spyOn(RedoclyClient.prototype, 'setAccessTokens').mockImplementation();
+    const client = new RedoclyClient('eu');
+    expect(client.setAccessTokens).toHaveBeenNthCalledWith(2, { "eu": REDOCLY_AUTHORIZATION_TOKEN });
+    spy.mockRestore();
+  });
+});