@redocly/cli 1.34.3 → 2.0.0-next.0

package/lib/reunite/commands/__tests__/push.test.js

@@ -1,315 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs = require("fs");
-const path = require("path");
-const push_1 = require("../push");
-const api_1 = require("../../api");
-const remotes = {
-    push: jest.fn(),
-    upsert: jest.fn(),
-    getDefaultBranch: jest.fn(),
-};
-jest.mock('@redocly/openapi-core', () => ({
-    slash: jest.fn().mockImplementation((p) => p),
-}));
-jest.mock('../../api', () => ({
-    ...jest.requireActual('../../api'),
-    ReuniteApi: jest.fn().mockImplementation(function (...args) {
-        this.remotes = remotes;
-        this.reportSunsetWarnings = jest.fn();
-    }),
-}));
-describe('handlePush()', () => {
-    let pathResolveSpy;
-    let pathRelativeSpy;
-    let pathDirnameSpy;
-    let fsStatSyncSpy;
-    let fsReaddirSyncSpy;
-    beforeEach(() => {
-        remotes.getDefaultBranch.mockResolvedValueOnce('test-default-branch');
-        remotes.upsert.mockResolvedValueOnce({ id: 'test-remote-id', mountPath: 'test-mount-path' });
-        remotes.push.mockResolvedValueOnce({ branchName: 'uploaded-to-branch', id: 'test-id' });
-        jest.spyOn(fs, 'createReadStream').mockReturnValue('stream');
-        pathResolveSpy = jest.spyOn(path, 'resolve');
-        pathRelativeSpy = jest.spyOn(path, 'relative');
-        pathDirnameSpy = jest.spyOn(path, 'dirname');
-        fsStatSyncSpy = jest.spyOn(fs, 'statSync');
-        fsReaddirSyncSpy = jest.spyOn(fs, 'readdirSync');
-    });
-    afterEach(() => {
-        pathResolveSpy.mockRestore();
-        pathRelativeSpy.mockRestore();
-        pathDirnameSpy.mockRestore();
-        fsStatSyncSpy.mockRestore();
-        fsReaddirSyncSpy.mockRestore();
-    });
-    it('should upload files', async () => {
-        const mockConfig = { apis: {} };
-        process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
-        fsStatSyncSpy.mockReturnValueOnce({
-            isDirectory() {
-                return false;
-            },
-        });
-        pathResolveSpy.mockImplementationOnce((p) => p);
-        pathRelativeSpy.mockImplementationOnce((_, p) => p);
-        pathDirnameSpy.mockImplementation((_) => '.');
-        await (0, push_1.handlePush)({
-            argv: {
-                domain: 'test-domain',
-                'mount-path': 'test-mount-path',
-                organization: 'test-org',
-                project: 'test-project',
-                branch: 'test-branch',
-                namespace: 'test-namespace',
-                repository: 'test-repository',
-                'commit-sha': 'test-commit-sha',
-                'commit-url': 'test-commit-url',
-                'default-branch': 'test-branch',
-                'created-at': 'test-created-at',
-                author: 'TestAuthor <test-author@mail.com>',
-                message: 'Test message',
-                files: ['test-file'],
-                'max-execution-time': 10,
-            },
-            config: mockConfig,
-            version: 'cli-version',
-        });
-        expect(remotes.getDefaultBranch).toHaveBeenCalledWith('test-org', 'test-project');
-        expect(remotes.upsert).toHaveBeenCalledWith('test-org', 'test-project', {
-            mountBranchName: 'test-default-branch',
-            mountPath: 'test-mount-path',
-        });
-        expect(remotes.push).toHaveBeenCalledWith('test-org', 'test-project', {
-            isMainBranch: true,
-            remoteId: 'test-remote-id',
-            commit: {
-                message: 'Test message',
-                branchName: 'test-branch',
-                createdAt: 'test-created-at',
-                namespace: 'test-namespace',
-                repository: 'test-repository',
-                sha: 'test-commit-sha',
-                url: 'test-commit-url',
-                author: {
-                    name: 'TestAuthor',
-                    email: 'test-author@mail.com',
-                },
-            },
-        }, [
-            {
-                path: 'test-file',
-                stream: 'stream',
-            },
-        ]);
-    });
-    it('should return push id', async () => {
-        const mockConfig = { apis: {} };
-        process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
-        fsStatSyncSpy.mockReturnValueOnce({
-            isDirectory() {
-                return false;
-            },
-        });
-        pathResolveSpy.mockImplementationOnce((p) => p);
-        pathRelativeSpy.mockImplementationOnce((_, p) => p);
-        pathDirnameSpy.mockImplementation((_) => '.');
-        const result = await (0, push_1.handlePush)({
-            argv: {
-                domain: 'test-domain',
-                'mount-path': 'test-mount-path',
-                organization: 'test-org',
-                project: 'test-project',
-                branch: 'test-branch',
-                namespace: 'test-namespace',
-                repository: 'test-repository',
-                'commit-sha': 'test-commit-sha',
-                'commit-url': 'test-commit-url',
-                'default-branch': 'test-branch',
-                'created-at': 'test-created-at',
-                author: 'TestAuthor <test-author@mail.com>',
-                message: 'Test message',
-                files: ['test-file'],
-                'max-execution-time': 10,
-            },
-            config: mockConfig,
-            version: 'cli-version',
-        });
-        expect(result).toEqual({ pushId: 'test-id' });
-    });
-    it('should collect files from directory and preserve file structure', async () => {
-        const mockConfig = { apis: {} };
-        process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
-        /*
-          ├── app
-          │   ├── index.html
-          ├── openapi.yaml
-          └── some-ref.yaml
-        */
-        fsStatSyncSpy.mockImplementation((filePath) => ({
-            isDirectory() {
-                return filePath === 'test-folder' || filePath === 'test-folder/app';
-            },
-        }));
-        fsReaddirSyncSpy.mockImplementation((dirPath) => {
-            if (dirPath === 'test-folder') {
-                return ['app', 'another-ref.yaml', 'openapi.yaml'];
-            }
-            if (dirPath === 'test-folder/app') {
-                return ['index.html'];
-            }
-            throw new Error('Not a directory');
-        });
-        await (0, push_1.handlePush)({
-            argv: {
-                domain: 'test-domain',
-                'mount-path': 'test-mount-path',
-                organization: 'test-org',
-                project: 'test-project',
-                branch: 'test-branch',
-                author: 'TestAuthor <test-author@mail.com>',
-                message: 'Test message',
-                'default-branch': 'main',
-                files: ['test-folder'],
-                'max-execution-time': 10,
-            },
-            config: mockConfig,
-            version: 'cli-version',
-        });
-        expect(remotes.push).toHaveBeenCalledWith(expect.anything(), expect.anything(), expect.anything(), [
-            {
-                path: 'app/index.html',
-                stream: 'stream',
-            },
-            {
-                path: 'another-ref.yaml',
-                stream: 'stream',
-            },
-            {
-                path: 'openapi.yaml',
-                stream: 'stream',
-            },
-        ]);
-    });
-    it('should not upload files if no files passed', async () => {
-        const mockConfig = { apis: {} };
-        process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
-        await (0, push_1.handlePush)({
-            argv: {
-                domain: 'test-domain',
-                'mount-path': 'test-mount-path',
-                organization: 'test-org',
-                project: 'test-project',
-                branch: 'test-branch',
-                author: 'TestAuthor <test-author@mail.com>',
-                message: 'Test message',
-                'default-branch': 'main',
-                files: [],
-                'max-execution-time': 10,
-            },
-            config: mockConfig,
-            version: 'cli-version',
-        });
-        expect(remotes.getDefaultBranch).not.toHaveBeenCalled();
-        expect(remotes.upsert).not.toHaveBeenCalled();
-        expect(remotes.push).not.toHaveBeenCalled();
-    });
-    it('should get organization from config if not passed', async () => {
-        const mockConfig = { organization: 'test-org-from-config', apis: {} };
-        process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
-        fsStatSyncSpy.mockReturnValueOnce({
-            isDirectory() {
-                return false;
-            },
-        });
-        pathResolveSpy.mockImplementationOnce((p) => p);
-        pathRelativeSpy.mockImplementationOnce((_, p) => p);
-        pathDirnameSpy.mockImplementation((_) => '.');
-        await (0, push_1.handlePush)({
-            argv: {
-                domain: 'test-domain',
-                'mount-path': 'test-mount-path',
-                project: 'test-project',
-                branch: 'test-branch',
-                author: 'TestAuthor <test-author@mail.com>',
-                message: 'Test message',
-                files: ['test-file'],
-                'default-branch': 'main',
-                'max-execution-time': 10,
-            },
-            config: mockConfig,
-            version: 'cli-version',
-        });
-        expect(remotes.getDefaultBranch).toHaveBeenCalledWith('test-org-from-config', expect.anything());
-        expect(remotes.upsert).toHaveBeenCalledWith('test-org-from-config', expect.anything(), expect.anything());
-        expect(remotes.push).toHaveBeenCalledWith('test-org-from-config', expect.anything(), expect.anything(), expect.anything());
-    });
-    it('should get domain from env if not passed', async () => {
-        const mockConfig = { organization: 'test-org-from-config', apis: {} };
-        process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
-        process.env.REDOCLY_DOMAIN = 'test-domain-from-env';
-        fsStatSyncSpy.mockReturnValueOnce({
-            isDirectory() {
-                return false;
-            },
-        });
-        pathResolveSpy.mockImplementationOnce((p) => p);
-        pathRelativeSpy.mockImplementationOnce((_, p) => p);
-        pathDirnameSpy.mockImplementation((_) => '.');
-        await (0, push_1.handlePush)({
-            argv: {
-                'mount-path': 'test-mount-path',
-                project: 'test-project',
-                branch: 'test-branch',
-                'default-branch': 'main',
-                author: 'TestAuthor <test-author@mail.com>',
-                message: 'Test message',
-                files: ['test-file'],
-                'max-execution-time': 10,
-            },
-            config: mockConfig,
-            version: 'cli-version',
-        });
-        expect(api_1.ReuniteApi).toBeCalledWith({
-            domain: 'test-domain-from-env',
-            apiKey: 'test-api-key',
-            version: 'cli-version',
-            command: 'push',
-        });
-    });
-    it('should print error message', async () => {
-        const mockConfig = { apis: {} };
-        process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
-        remotes.push.mockRestore();
-        remotes.push.mockRejectedValueOnce(new api_1.ReuniteApiError('Deprecated.', 412));
-        fsStatSyncSpy.mockReturnValueOnce({
-            isDirectory() {
-                return false;
-            },
-        });
-        pathResolveSpy.mockImplementationOnce((p) => p);
-        pathRelativeSpy.mockImplementationOnce((_, p) => p);
-        pathDirnameSpy.mockImplementation((_) => '.');
-        expect((0, push_1.handlePush)({
-            argv: {
-                domain: 'test-domain',
-                'mount-path': 'test-mount-path',
-                organization: 'test-org',
-                project: 'test-project',
-                branch: 'test-branch',
-                namespace: 'test-namespace',
-                repository: 'test-repository',
-                'commit-sha': 'test-commit-sha',
-                'commit-url': 'test-commit-url',
-                'default-branch': 'test-branch',
-                'created-at': 'test-created-at',
-                author: 'TestAuthor <test-author@mail.com>',
-                message: 'Test message',
-                files: ['test-file'],
-                'max-execution-time': 10,
-            },
-            config: mockConfig,
-            version: 'cli-version',
-        })).rejects.toThrow('✗ File upload failed. Reason: Deprecated.');
-    });
-});

package/lib/reunite/commands/__tests__/utils.test.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/reunite/commands/__tests__/utils.test.js

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("../utils");
-jest.mock('@redocly/openapi-core', () => ({
-    pause: jest.requireActual('@redocly/openapi-core').pause,
-}));
-describe('retryUntilConditionMet()', () => {
-    it('should retry until condition meet and return result', async () => {
-        const operation = jest
-            .fn()
-            .mockResolvedValueOnce({ status: 'pending' })
-            .mockResolvedValueOnce({ status: 'pending' })
-            .mockResolvedValueOnce({ status: 'done' });
-        const data = await (0, utils_1.retryUntilConditionMet)({
-            operation,
-            condition: (result) => result?.status === 'done',
-            retryIntervalMs: 100,
-            retryTimeoutMs: 1000,
-        });
-        expect(data).toEqual({ status: 'done' });
-    });
-    it('should throw error if condition not meet for desired timeout', async () => {
-        const operation = jest.fn().mockResolvedValue({ status: 'pending' });
-        await expect((0, utils_1.retryUntilConditionMet)({
-            operation,
-            condition: (result) => result?.status === 'done',
-            retryIntervalMs: 100,
-            retryTimeoutMs: 1000,
-        })).rejects.toThrow('Timeout exceeded.');
-    });
-    it('should call "onConditionNotMet" and "onRetry" callbacks', async () => {
-        const operation = jest
-            .fn()
-            .mockResolvedValueOnce({ status: 'pending' })
-            .mockResolvedValueOnce({ status: 'pending' })
-            .mockResolvedValueOnce({ status: 'done' });
-        const onConditionNotMet = jest.fn();
-        const onRetry = jest.fn();
-        const data = await (0, utils_1.retryUntilConditionMet)({
-            operation,
-            condition: (result) => result?.status === 'done',
-            retryIntervalMs: 100,
-            retryTimeoutMs: 1000,
-            onConditionNotMet,
-            onRetry,
-        });
-        expect(data).toEqual({ status: 'done' });
-        expect(onConditionNotMet).toHaveBeenCalledTimes(2);
-        expect(onRetry).toHaveBeenCalledTimes(2);
-    });
-});

package/lib/utils/__mocks__/miscellaneous.d.ts

@@ -1,43 +0,0 @@
-export declare const getFallbackApisOrExit: jest.Mock<any, [entrypoints: any]>;
-export declare const dumpBundle: jest.Mock<string, []>;
-export declare const slash: jest.Mock<any, any>;
-export declare const pluralize: jest.Mock<any, any>;
-export declare const getExecutionTime: jest.Mock<any, any>;
-export declare const printExecutionTime: jest.Mock<any, any>;
-export declare const printUnusedWarnings: jest.Mock<any, any>;
-export declare const printLintTotals: jest.Mock<any, any>;
-export declare const getOutputFileName: jest.Mock<{
-    outputFile: string;
-    ext: string;
-}, []>;
-export declare const handleError: jest.Mock<any, any>;
-export declare const exitWithError: jest.Mock<any, any>;
-export declare const writeYaml: jest.Mock<any, any>;
-export declare const loadConfigAndHandleErrors: jest.Mock<{
-    configFile: null;
-    styleguide: {
-        addIgnore: jest.Mock<any, any>;
-        skipRules: jest.Mock<any, any>;
-        skipPreprocessors: jest.Mock<any, any>;
-        saveIgnore: jest.Mock<any, any>;
-        skipDecorators: jest.Mock<any, any>;
-        ignore: null;
-        decorators: {
-            oas2: {};
-            oas3_0: {};
-            oas3_1: {};
-        };
-        preprocessors: {
-            oas2: {};
-            oas3_0: {};
-            oas3_1: {};
-        };
-    };
-}, []>;
-export declare const checkIfRulesetExist: jest.Mock<any, any>;
-export declare const sortTopLevelKeysForOas: jest.Mock<any, [document: any]>;
-export declare const getAndValidateFileExtension: jest.Mock<string | undefined, [fileName: string]>;
-export declare const writeToFileByExtension: jest.Mock<any, any>;
-export declare const checkForDeprecatedOptions: jest.Mock<any, any>;
-export declare const saveBundle: jest.Mock<any, any>;
-export declare const formatPath: jest.Mock<string, [path: string]>;

package/lib/utils/__mocks__/miscellaneous.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatPath = exports.saveBundle = exports.checkForDeprecatedOptions = exports.writeToFileByExtension = exports.getAndValidateFileExtension = exports.sortTopLevelKeysForOas = exports.checkIfRulesetExist = exports.loadConfigAndHandleErrors = exports.writeYaml = exports.exitWithError = exports.handleError = exports.getOutputFileName = exports.printLintTotals = exports.printUnusedWarnings = exports.printExecutionTime = exports.getExecutionTime = exports.pluralize = exports.slash = exports.dumpBundle = exports.getFallbackApisOrExit = void 0;
-const config_1 = require("../../__tests__/fixtures/config");
-exports.getFallbackApisOrExit = jest.fn((entrypoints) => entrypoints.map((path) => ({ path })));
-exports.dumpBundle = jest.fn(() => '');
-exports.slash = jest.fn();
-exports.pluralize = jest.fn();
-exports.getExecutionTime = jest.fn();
-exports.printExecutionTime = jest.fn();
-exports.printUnusedWarnings = jest.fn();
-exports.printLintTotals = jest.fn();
-exports.getOutputFileName = jest.fn(() => ({ outputFile: 'test.yaml', ext: 'yaml' }));
-exports.handleError = jest.fn();
-exports.exitWithError = jest.fn();
-exports.writeYaml = jest.fn();
-exports.loadConfigAndHandleErrors = jest.fn(() => config_1.ConfigFixture);
-exports.checkIfRulesetExist = jest.fn();
-exports.sortTopLevelKeysForOas = jest.fn((document) => document);
-exports.getAndValidateFileExtension = jest.fn((fileName) => fileName.split('.').pop());
-exports.writeToFileByExtension = jest.fn();
-exports.checkForDeprecatedOptions = jest.fn();
-exports.saveBundle = jest.fn();
-exports.formatPath = jest.fn((path) => path);

package/lib/utils/getCommandNameFromArgs.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCommandNameFromArgs = getCommandNameFromArgs;
-function getCommandNameFromArgs(argv) {
-    return argv?._?.[0] ?? '';
-}

package/src/__mocks__/@redocly/openapi-core.ts

@@ -1,88 +0,0 @@
-import { ConfigFixture } from './../../__tests__/fixtures/config';
-import { firstDocument, secondDocument, thirdDocument } from '../documents';
-
-import type { Document } from '@redocly/openapi-core';
-
-export const __redoclyClient = {
-  isAuthorizedWithRedocly: jest.fn().mockResolvedValue(true),
-  isAuthorizedWithRedoclyByRegion: jest.fn().mockResolvedValue(true),
-  login: jest.fn(),
-  registryApi: {
-    setAccessTokens: jest.fn(),
-    authStatus: jest.fn(),
-    prepareFileUpload: jest.fn().mockResolvedValue({
-      signedUploadUrl: 'signedUploadUrl',
-      filePath: 'filePath',
-    }),
-    pushApi: jest.fn(),
-  },
-};
-
-export const RedoclyClient = jest.fn(() => __redoclyClient);
-export const loadConfig = jest.fn(() => ConfigFixture);
-export const getMergedConfig = jest.fn();
-export const getProxyAgent = jest.fn();
-export const lint = jest.fn();
-export const bundle = jest.fn(() => ({ bundle: { parsed: null }, problems: null }));
-export const getTotals = jest.fn(() => ({ errors: 0 }));
-export const formatProblems = jest.fn();
-export const slash = jest.fn();
-export const findConfig = jest.fn();
-export const doesYamlFileExist = jest.fn();
-export const bundleDocument = jest.fn(() => Promise.resolve({ problems: {} }));
-export const detectSpec = jest.fn();
-export const isAbsoluteUrl = jest.fn();
-export const stringifyYaml = jest.fn((data) => data);
-
-export class BaseResolver {
-  cache = new Map<string, Promise<Document | ResolveError>>();
-
-  getFiles = jest.fn();
-  resolveExternalRef = jest.fn();
-  loadExternalRef = jest.fn;
-  parseDocument = jest.fn();
-  resolveDocument = jest
-    .fn()
-    .mockImplementationOnce(() =>
-      Promise.resolve({ source: { absoluteRef: 'ref' }, parsed: firstDocument })
-    )
-    .mockImplementationOnce(() =>
-      Promise.resolve({ source: { absoluteRef: 'ref' }, parsed: secondDocument })
-    )
-    .mockImplementationOnce(() =>
-      Promise.resolve({ source: { absoluteRef: 'ref' }, parsed: thirdDocument })
-    );
-}
-
-export class ResolveError extends Error {
-  constructor(public originalError: Error) {
-    super(originalError.message);
-    Object.setPrototypeOf(this, ResolveError.prototype);
-  }
-}
-
-export class YamlParseError extends Error {
-  constructor(public originalError: Error) {
-    super(originalError.message);
-    Object.setPrototypeOf(this, YamlParseError.prototype);
-  }
-}
-
-export enum SpecVersion {
-  OAS2 = 'oas2',
-  OAS3_0 = 'oas3_0',
-  OAS3_1 = 'oas3_1',
-  Async2 = 'async2',
-  Async3 = 'async3',
-}
-
-export enum Oas3Operations {
-  get = 'get',
-  put = 'put',
-  post = 'post',
-  delete = 'delete',
-  options = 'options',
-  head = 'head',
-  patch = 'patch',
-  trace = 'trace',
-}

package/src/__mocks__/documents.ts

@@ -1,124 +0,0 @@
-export const firstDocument = {
-  openapi: '3.0.0',
-  servers: [{ url: 'http://localhost:8080' }],
-  info: {
-    description: 'example test',
-    version: '1.0.0',
-    title: 'First API',
-    termsOfService: 'http://swagger.io/terms/',
-    license: {
-      name: 'Apache 2.0',
-      url: 'http://www.apache.org/licenses/LICENSE-2.0.html',
-    },
-  },
-  paths: {
-    '/GETUser/{userId}': {
-      summary: 'get user by id',
-      description: 'user info',
-      servers: [{ url: '/user' }, { url: '/pet', description: 'pet server' }],
-
-      get: {
-        tags: ['pet'],
-        summary: 'Find pet by ID',
-        description: 'Returns a single pet',
-        operationId: 'getPetById',
-        servers: [{ url: '/pet' }],
-      },
-      parameters: [{ name: 'param1', in: 'header', schema: { description: 'string' } }],
-    },
-  },
-  components: {},
-};
-
-export const secondDocument = {
-  openapi: '3.0.0',
-  servers: [{ url: 'http://localhost:8080' }],
-  info: {
-    description: 'example test',
-    version: '1.0.0',
-    title: 'Second API',
-    termsOfService: 'http://swagger.io/terms/',
-    license: {
-      name: 'Apache 2.0',
-      url: 'http://www.apache.org/licenses/LICENSE-2.0.html',
-    },
-  },
-  post: {
-    '/GETUser/{userId}': {
-      summary: 'get user',
-      description: 'user information',
-      servers: [{ url: '/user' }, { url: '/pet', description: '' }],
-
-      get: {
-        tags: ['pet'],
-        summary: 'Find pet by ID',
-        description: 'Returns a single pet',
-        operationId: 'getPetById',
-        servers: [{ url: '/pet' }],
-      },
-      parameters: [{ name: 'param1', in: 'header', schema: { description: 'string' } }],
-    },
-  },
-  components: {},
-};
-
-export const thirdDocument = {
-  openapi: '3.0.0',
-  info: {
-    title: 'Third API',
-    version: '1.0',
-  },
-  servers: [
-    {
-      url: 'https://api.server.test/v1',
-    },
-  ],
-  paths: {},
-  components: {
-    schemas: {
-      SchemaWithNull: {
-        type: 'string',
-        default: null,
-        nullable: true,
-      },
-      SchemaWithRef: {
-        type: 'object',
-        properties: {
-          schemaType: {
-            type: 'string',
-            enum: ['foo'],
-          },
-          foo: {
-            $ref: '#/components/schemas/SchemaWithNull',
-          },
-        },
-      },
-      SchemaWithDiscriminator: {
-        discriminator: {
-          propertyName: 'schemaType',
-          mapping: {
-            foo: '#/components/schemas/SchemaWithRef',
-            bar: '#/components/schemas/SchemaWithNull',
-          },
-        },
-        oneOf: [
-          {
-            $ref: '#/components/schemas/SchemaWithRef',
-          },
-          {
-            type: 'object',
-            properties: {
-              schemaType: {
-                type: 'string',
-                enum: ['bar'],
-              },
-              bar: {
-                type: 'string',
-              },
-            },
-          },
-        ],
-      },
-    },
-  },
-};

package/src/__mocks__/fs.ts

@@ -1,6 +0,0 @@
-export const existsSync = jest.fn();
-export const readFileSync = jest.fn(() => '');
-export const statSync = jest.fn(() => ({ size: 0 }));
-export const createReadStream = jest.fn();
-export const writeFileSync = jest.fn();
-export const mkdirSync = jest.fn();

package/src/__mocks__/perf_hooks.ts

@@ -1,3 +0,0 @@
-export const performance = {
-  now: jest.fn(),
-};

package/src/__mocks__/redoc.ts

@@ -1,2 +0,0 @@
-export const loadAndBundleSpec = jest.fn(() => Promise.resolve({ openapi: '3.0.0' }));
-export const createStore = jest.fn(() => Promise.resolve({ toJS: jest.fn(() => '{}') }));