@redocly/cli 0.0.0-snapshot.1737554067

package/lib/__tests__/commands/push-region.test.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const openapi_core_1 = require("@redocly/openapi-core");
+const push_1 = require("../../commands/push");
+const login_1 = require("../../commands/login");
+const config_1 = require("../fixtures/config");
+jest.mock('fs');
+jest.mock('node-fetch', () => ({
+    default: jest.fn(() => ({
+        ok: true,
+        json: jest.fn().mockResolvedValue({}),
+    })),
+}));
+jest.mock('@redocly/openapi-core');
+jest.mock('../../commands/login');
+jest.mock('../../utils/miscellaneous');
+openapi_core_1.getMergedConfig.mockImplementation((config) => config);
+const mockPromptClientToken = login_1.promptClientToken;
+describe('push-with-region', () => {
+    const redoclyClient = require('@redocly/openapi-core').__redoclyClient;
+    redoclyClient.isAuthorizedWithRedoclyByRegion = jest.fn().mockResolvedValue(false);
+    beforeAll(() => {
+        jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+    });
+    it('should call login with default domain when region is US', async () => {
+        redoclyClient.domain = 'redoc.ly';
+        await (0, push_1.handlePush)({
+            argv: {
+                upsert: true,
+                api: 'spec.json',
+                destination: '@org/my-api@1.0.0',
+                branchName: 'test',
+            },
+            config: config_1.ConfigFixture,
+            version: 'cli-version',
+        });
+        expect(mockPromptClientToken).toBeCalledTimes(1);
+        expect(mockPromptClientToken).toHaveBeenCalledWith(redoclyClient.domain);
+    });
+    it('should call login with EU domain when region is EU', async () => {
+        redoclyClient.domain = 'eu.redocly.com';
+        await (0, push_1.handlePush)({
+            argv: {
+                upsert: true,
+                api: 'spec.json',
+                destination: '@org/my-api@1.0.0',
+                branchName: 'test',
+            },
+            config: config_1.ConfigFixture,
+            version: 'cli-version',
+        });
+        expect(mockPromptClientToken).toBeCalledTimes(1);
+        expect(mockPromptClientToken).toHaveBeenCalledWith(redoclyClient.domain);
+    });
+});

package/lib/__tests__/commands/push.test.d.ts

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

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

@@ -0,0 +1,463 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs");
+const openapi_core_1 = require("@redocly/openapi-core");
+const miscellaneous_1 = require("../../utils/miscellaneous");
+const push_1 = require("../../commands/push");
+const config_1 = require("../fixtures/config");
+const colorette_1 = require("colorette");
+jest.mock('fs');
+jest.mock('node-fetch', () => ({
+    default: jest.fn(() => ({
+        ok: true,
+        json: jest.fn().mockResolvedValue({}),
+    })),
+}));
+jest.mock('@redocly/openapi-core');
+jest.mock('../../utils/miscellaneous');
+openapi_core_1.getMergedConfig.mockImplementation((config) => config);
+describe('push', () => {
+    const redoclyClient = require('@redocly/openapi-core').__redoclyClient;
+    beforeEach(() => {
+        jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+    });
+    it('pushes definition', async () => {
+        await (0, push_1.handlePush)({
+            argv: {
+                upsert: true,
+                api: 'spec.json',
+                destination: '@org/my-api@1.0.0',
+                branchName: 'test',
+                public: true,
+                'job-id': '123',
+                'batch-size': 2,
+            },
+            config: config_1.ConfigFixture,
+            version: 'cli-version',
+        });
+        expect(redoclyClient.registryApi.prepareFileUpload).toBeCalledTimes(1);
+        expect(redoclyClient.registryApi.pushApi).toBeCalledTimes(1);
+        expect(redoclyClient.registryApi.pushApi).toHaveBeenLastCalledWith({
+            branch: 'test',
+            filePaths: ['filePath'],
+            isUpsert: true,
+            isPublic: true,
+            name: 'my-api',
+            organizationId: 'org',
+            rootFilePath: 'filePath',
+            version: '1.0.0',
+            batchId: '123',
+            batchSize: 2,
+        });
+    });
+    it('fails if jobId value is an empty string', async () => {
+        await (0, push_1.handlePush)({
+            argv: {
+                upsert: true,
+                api: 'spec.json',
+                destination: '@org/my-api@1.0.0',
+                branchName: 'test',
+                public: true,
+                'job-id': ' ',
+                'batch-size': 2,
+            },
+            config: config_1.ConfigFixture,
+            version: 'cli-version',
+        });
+        expect(miscellaneous_1.exitWithError).toBeCalledTimes(1);
+    });
+    it('fails if batchSize value is less than 2', async () => {
+        await (0, push_1.handlePush)({
+            argv: {
+                upsert: true,
+                api: 'spec.json',
+                destination: '@org/my-api@1.0.0',
+                branchName: 'test',
+                public: true,
+                'job-id': '123',
+                'batch-size': 1,
+            },
+            config: config_1.ConfigFixture,
+            version: 'cli-version',
+        });
+        expect(miscellaneous_1.exitWithError).toBeCalledTimes(1);
+    });
+    it('push with --files', async () => {
+        const mockConfig = { ...config_1.ConfigFixture, files: ['./resouces/1.md', './resouces/2.md'] };
+        fs.statSync.mockImplementation(() => {
+            return { isDirectory: () => false, size: 10 };
+        });
+        await (0, push_1.handlePush)({
+            argv: {
+                upsert: true,
+                api: 'spec.json',
+                destination: '@org/my-api@1.0.0',
+                public: true,
+                files: ['./resouces/1.md', './resouces/2.md'],
+            },
+            config: mockConfig,
+            version: 'cli-version',
+        });
+        expect(redoclyClient.registryApi.pushApi).toHaveBeenLastCalledWith({
+            filePaths: ['filePath', 'filePath', 'filePath'],
+            isUpsert: true,
+            isPublic: true,
+            name: 'my-api',
+            organizationId: 'org',
+            rootFilePath: 'filePath',
+            version: '1.0.0',
+        });
+        expect(redoclyClient.registryApi.prepareFileUpload).toBeCalledTimes(3);
+    });
+    it('push should fail if organization not provided', async () => {
+        await (0, push_1.handlePush)({
+            argv: {
+                upsert: true,
+                api: 'spec.json',
+                destination: 'test@v1',
+                branchName: 'test',
+                public: true,
+                'job-id': '123',
+                'batch-size': 2,
+            },
+            config: config_1.ConfigFixture,
+            version: 'cli-version',
+        });
+        expect(miscellaneous_1.exitWithError).toBeCalledTimes(1);
+        expect(miscellaneous_1.exitWithError).toBeCalledWith(`No organization provided, please use --organization option or specify the 'organization' field in the config file.`);
+    });
+    it('push should work with organization in config', async () => {
+        const mockConfig = { ...config_1.ConfigFixture, organization: 'test_org' };
+        await (0, push_1.handlePush)({
+            argv: {
+                upsert: true,
+                api: 'spec.json',
+                destination: 'my-api@1.0.0',
+                branchName: 'test',
+                public: true,
+                'job-id': '123',
+                'batch-size': 2,
+            },
+            config: mockConfig,
+            version: 'cli-version',
+        });
+        expect(redoclyClient.registryApi.pushApi).toBeCalledTimes(1);
+        expect(redoclyClient.registryApi.pushApi).toHaveBeenLastCalledWith({
+            branch: 'test',
+            filePaths: ['filePath'],
+            isUpsert: true,
+            isPublic: true,
+            name: 'my-api',
+            organizationId: 'test_org',
+            rootFilePath: 'filePath',
+            version: '1.0.0',
+            batchId: '123',
+            batchSize: 2,
+        });
+    });
+    it('push should work if destination not provided but api in config is provided', async () => {
+        const mockConfig = {
+            ...config_1.ConfigFixture,
+            organization: 'test_org',
+            apis: { 'my-api@1.0.0': { root: 'path' } },
+        };
+        await (0, push_1.handlePush)({
+            argv: {
+                upsert: true,
+                branchName: 'test',
+                public: true,
+                'job-id': '123',
+                'batch-size': 2,
+            },
+            config: mockConfig,
+            version: 'cli-version',
+        });
+        expect(redoclyClient.registryApi.pushApi).toBeCalledTimes(1);
+    });
+    it('push should fail if apis not provided', async () => {
+        const mockConfig = { organization: 'test_org', apis: {} };
+        await (0, push_1.handlePush)({
+            argv: {
+                upsert: true,
+                branchName: 'test',
+                public: true,
+                'job-id': '123',
+                'batch-size': 2,
+            },
+            config: mockConfig,
+            version: 'cli-version',
+        });
+        expect(miscellaneous_1.exitWithError).toBeCalledTimes(1);
+        expect(miscellaneous_1.exitWithError).toHaveBeenLastCalledWith('Api not found. Please make sure you have provided the correct data in the config file.');
+    });
+    it('push should fail if destination not provided', async () => {
+        const mockConfig = { organization: 'test_org', apis: {} };
+        await (0, push_1.handlePush)({
+            argv: {
+                upsert: true,
+                api: 'api.yaml',
+                branchName: 'test',
+                public: true,
+                'job-id': '123',
+                'batch-size': 2,
+            },
+            config: mockConfig,
+            version: 'cli-version',
+        });
+        expect(miscellaneous_1.exitWithError).toBeCalledTimes(1);
+        expect(miscellaneous_1.exitWithError).toHaveBeenLastCalledWith('No destination provided, please use --destination option to provide destination.');
+    });
+    it('push should fail if destination format is not valid', async () => {
+        const mockConfig = { organization: 'test_org', apis: {} };
+        await (0, push_1.handlePush)({
+            argv: {
+                upsert: true,
+                destination: 'name/v1',
+                branchName: 'test',
+                public: true,
+                'job-id': '123',
+                'batch-size': 2,
+            },
+            config: mockConfig,
+            version: 'cli-version',
+        });
+        expect(miscellaneous_1.exitWithError).toHaveBeenCalledWith(`Destination argument value is not valid, please use the right format: ${(0, colorette_1.yellow)('<api-name@api-version>')}.`);
+    });
+    it('push should work and encode name with spaces', async () => {
+        const encodeURIComponentSpy = jest.spyOn(global, 'encodeURIComponent');
+        const mockConfig = {
+            ...config_1.ConfigFixture,
+            organization: 'test_org',
+            apis: { 'my test api@v1': { root: 'path' } },
+        };
+        await (0, push_1.handlePush)({
+            argv: {
+                upsert: true,
+                destination: 'my test api@v1',
+                branchName: 'test',
+                public: true,
+                'job-id': '123',
+                'batch-size': 2,
+            },
+            config: mockConfig,
+            version: 'cli-version',
+        });
+        expect(encodeURIComponentSpy).toHaveReturnedWith('my%20test%20api');
+        expect(redoclyClient.registryApi.pushApi).toBeCalledTimes(1);
+    });
+});
+describe('transformPush', () => {
+    it('should adapt the existing syntax', () => {
+        const cb = jest.fn();
+        (0, push_1.transformPush)(cb)({
+            argv: {
+                apis: ['openapi.yaml', '@testing_org/main@v1'],
+            },
+            config: {},
+            version: 'cli-version',
+        });
+        expect(cb).toBeCalledWith({
+            argv: {
+                api: 'openapi.yaml',
+                destination: '@testing_org/main@v1',
+            },
+            config: {},
+            version: 'cli-version',
+        });
+    });
+    it('should adapt the existing syntax (including branchName)', () => {
+        const cb = jest.fn();
+        (0, push_1.transformPush)(cb)({
+            argv: {
+                apis: ['openapi.yaml', '@testing_org/main@v1', 'other'],
+            },
+            config: {},
+            version: 'cli-version',
+        });
+        expect(cb).toBeCalledWith({
+            argv: {
+                api: 'openapi.yaml',
+                destination: '@testing_org/main@v1',
+                branchName: 'other',
+            },
+            config: {},
+            version: 'cli-version',
+        });
+    });
+    it('should use --branch option firstly', () => {
+        const cb = jest.fn();
+        (0, push_1.transformPush)(cb)({
+            argv: {
+                apis: ['openapi.yaml', '@testing_org/main@v1', 'other'],
+                branch: 'priority-branch',
+            },
+            config: {},
+            version: 'cli-version',
+        });
+        expect(cb).toBeCalledWith({
+            argv: {
+                api: 'openapi.yaml',
+                destination: '@testing_org/main@v1',
+                branchName: 'priority-branch',
+            },
+            config: {},
+            version: 'cli-version',
+        });
+    });
+    it('should work for a destination only', () => {
+        const cb = jest.fn();
+        (0, push_1.transformPush)(cb)({
+            argv: {
+                apis: ['main@v1'],
+            },
+            config: {},
+            version: 'cli-version',
+        });
+        expect(cb).toBeCalledWith({
+            argv: {
+                destination: 'main@v1',
+            },
+            config: {},
+            version: 'cli-version',
+        });
+    });
+    it('should work for a api only', () => {
+        const cb = jest.fn();
+        (0, push_1.transformPush)(cb)({
+            argv: {
+                apis: ['test.yaml'],
+            },
+            config: {},
+            version: 'cli-version',
+        });
+        expect(cb).toBeCalledWith({
+            argv: {
+                api: 'test.yaml',
+            },
+            config: {},
+            version: 'cli-version',
+        });
+    });
+    it('should use destination from option', () => {
+        const cb = jest.fn();
+        (0, push_1.transformPush)(cb)({
+            argv: {
+                apis: ['test.yaml', 'test@v1'],
+                destination: 'main@v1',
+            },
+            config: {},
+            version: 'cli-version',
+        });
+        expect(cb).toBeCalledWith({
+            argv: {
+                destination: 'main@v1',
+                api: 'test.yaml',
+            },
+            config: {},
+            version: 'cli-version',
+        });
+    });
+    it('should use --job-id option firstly', () => {
+        const cb = jest.fn();
+        (0, push_1.transformPush)(cb)({
+            argv: {
+                'batch-id': 'b-123',
+                'job-id': 'j-123',
+                apis: ['test'],
+                branch: 'test',
+                destination: 'main@v1',
+            },
+            config: {},
+            version: 'cli-version',
+        });
+        expect(cb).toBeCalledWith({
+            argv: {
+                'job-id': 'j-123',
+                api: 'test',
+                branchName: 'test',
+                destination: 'main@v1',
+            },
+            config: {},
+            version: 'cli-version',
+        });
+    });
+    it('should accept no arguments at all', () => {
+        const cb = jest.fn();
+        (0, push_1.transformPush)(cb)({ argv: {}, config: {}, version: 'cli-version' });
+        expect(cb).toBeCalledWith({ argv: {}, config: {}, version: 'cli-version' });
+    });
+});
+describe('getDestinationProps', () => {
+    it('should get valid destination props for the full destination syntax', () => {
+        expect((0, push_1.getDestinationProps)('@testing_org/main@v1', 'org-from-config')).toEqual({
+            organizationId: 'testing_org',
+            name: 'main',
+            version: 'v1',
+        });
+    });
+    it('should fallback the organizationId from a config for the short destination syntax', () => {
+        expect((0, push_1.getDestinationProps)('main@v1', 'org-from-config')).toEqual({
+            organizationId: 'org-from-config',
+            name: 'main',
+            version: 'v1',
+        });
+    });
+    it('should fallback the organizationId from a config if no destination provided', () => {
+        expect((0, push_1.getDestinationProps)(undefined, 'org-from-config')).toEqual({
+            organizationId: 'org-from-config',
+        });
+    });
+    it('should return empty organizationId if there is no one found', () => {
+        expect((0, push_1.getDestinationProps)('main@v1', undefined)).toEqual({
+            organizationId: undefined,
+            name: 'main',
+            version: 'v1',
+        });
+    });
+    it('should return organizationId from destination string', () => {
+        expect((0, push_1.getDestinationProps)('@test-org/main@main-v1', undefined)).toEqual({
+            organizationId: 'test-org',
+            name: 'main',
+            version: 'main-v1',
+        });
+    });
+    it('should return organizationId, version and empty name from destination string', () => {
+        expect((0, push_1.getDestinationProps)('@test_org/@main_v1', undefined)).toEqual({
+            organizationId: 'test_org',
+            name: '',
+            version: 'main_v1',
+        });
+    });
+    it('should validate organizationId with space and version with dot', () => {
+        expect((0, push_1.getDestinationProps)('@test org/simple_name@main.v1', undefined)).toEqual({
+            organizationId: 'test org',
+            name: 'simple_name',
+            version: 'main.v1',
+        });
+    });
+    it('should not work with "@" in destination name', () => {
+        expect((0, push_1.getDestinationProps)('@test org/simple@name@main.v1', undefined)).toEqual({
+            organizationId: undefined,
+            name: undefined,
+            version: undefined,
+        });
+    });
+});
+describe('getApiRoot', () => {
+    let config = {
+        apis: {
+            'main@v1': {
+                root: 'openapi.yaml',
+            },
+            main: {
+                root: 'latest.yaml',
+            },
+        },
+    };
+    it('should resolve the correct api for a valid name & version', () => {
+        expect((0, push_1.getApiRoot)({ name: 'main', version: 'v1', config })).toEqual('openapi.yaml');
+    });
+    it('should resolve the latest version of api if there is no matching version', () => {
+        expect((0, push_1.getApiRoot)({ name: 'main', version: 'latest', config })).toEqual('latest.yaml');
+    });
+});

package/lib/__tests__/fetch-with-timeout.test.d.ts

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

package/lib/__tests__/fetch-with-timeout.test.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const abort_controller_1 = require("abort-controller");
+const fetch_with_timeout_1 = require("../utils/fetch-with-timeout");
+const node_fetch_1 = require("node-fetch");
+const openapi_core_1 = require("@redocly/openapi-core");
+const https_proxy_agent_1 = require("https-proxy-agent");
+jest.mock('node-fetch');
+jest.mock('@redocly/openapi-core');
+describe('fetchWithTimeout', () => {
+    beforeAll(() => {
+        // @ts-ignore
+        global.setTimeout = jest.fn();
+        global.clearTimeout = jest.fn();
+    });
+    beforeEach(() => {
+        openapi_core_1.getProxyAgent.mockReturnValueOnce(undefined);
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should call node-fetch with signal', async () => {
+        await (0, fetch_with_timeout_1.default)('url', { timeout: 1000 });
+        expect(global.setTimeout).toHaveBeenCalledTimes(1);
+        expect(node_fetch_1.default).toHaveBeenCalledWith('url', {
+            signal: new abort_controller_1.default().signal,
+            agent: undefined,
+        });
+        expect(global.clearTimeout).toHaveBeenCalledTimes(1);
+    });
+    it('should call node-fetch with proxy agent', async () => {
+        openapi_core_1.getProxyAgent.mockRestore();
+        const proxyAgent = new https_proxy_agent_1.HttpsProxyAgent('http://localhost');
+        openapi_core_1.getProxyAgent.mockReturnValueOnce(proxyAgent);
+        await (0, fetch_with_timeout_1.default)('url');
+        expect(node_fetch_1.default).toHaveBeenCalledWith('url', { agent: proxyAgent });
+    });
+    it('should call node-fetch without signal when timeout is not passed', async () => {
+        await (0, fetch_with_timeout_1.default)('url');
+        expect(global.setTimeout).not.toHaveBeenCalled();
+        expect(node_fetch_1.default).toHaveBeenCalledWith('url', { agent: undefined });
+        expect(global.clearTimeout).not.toHaveBeenCalled();
+    });
+});

package/lib/__tests__/fixtures/config.d.ts

@@ -0,0 +1,21 @@
+export declare const ConfigFixture: {
+    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: {};
+        };
+    };
+};

package/lib/__tests__/fixtures/config.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigFixture = void 0;
+exports.ConfigFixture = {
+    configFile: null,
+    styleguide: {
+        addIgnore: jest.fn(),
+        skipRules: jest.fn(),
+        skipPreprocessors: jest.fn(),
+        saveIgnore: jest.fn(),
+        skipDecorators: jest.fn(),
+        ignore: null,
+        decorators: {
+            oas2: {},
+            oas3_0: {},
+            oas3_1: {},
+        },
+        preprocessors: {
+            oas2: {},
+            oas3_0: {},
+            oas3_1: {},
+        },
+    },
+};

package/lib/__tests__/spinner.test.d.ts

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

package/lib/__tests__/spinner.test.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const spinner_1 = require("../utils/spinner");
+const process = require("process");
+jest.useFakeTimers();
+describe('Spinner', () => {
+    const IS_TTY = process.stdout.isTTY;
+    let writeMock;
+    let spinner;
+    beforeEach(() => {
+        process.stdout.isTTY = true;
+        writeMock = jest.spyOn(process.stdout, 'write').mockImplementation(jest.fn());
+        spinner = new spinner_1.Spinner();
+    });
+    afterEach(() => {
+        writeMock.mockRestore();
+        jest.clearAllTimers();
+    });
+    afterAll(() => {
+        process.stdout.isTTY = IS_TTY;
+    });
+    it('starts the spinner', () => {
+        spinner.start('Loading');
+        jest.advanceTimersByTime(100);
+        expect(writeMock).toHaveBeenCalledWith('\r⠋ Loading');
+    });
+    it('stops the spinner', () => {
+        spinner.start('Loading');
+        spinner.stop();
+        expect(writeMock).toHaveBeenCalledWith('\r');
+    });
+    it('should write 3 frames', () => {
+        spinner.start('Loading');
+        jest.advanceTimersByTime(300);
+        expect(writeMock).toHaveBeenCalledTimes(3);
+    });
+    it('should call write 1 times if CI set to true', () => {
+        process.stdout.isTTY = false;
+        spinner.start('Loading');
+        jest.advanceTimersByTime(300);
+        expect(writeMock).toHaveBeenCalledTimes(1);
+    });
+});

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

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