@redocly/cli 1.34.4 → 2.0.0-next.0

package/src/reunite/commands/__tests__/push.test.ts

@@ -1,385 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { handlePush } from '../push';
-import { ReuniteApi, ReuniteApiError } from '../../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 (this: any, ...args) {
-    this.remotes = remotes;
-    this.reportSunsetWarnings = jest.fn();
-  }),
-}));
-
-describe('handlePush()', () => {
-  let pathResolveSpy: jest.SpyInstance;
-  let pathRelativeSpy: jest.SpyInstance;
-  let pathDirnameSpy: jest.SpyInstance;
-  let fsStatSyncSpy: jest.SpyInstance;
-  let fsReaddirSyncSpy: jest.SpyInstance;
-
-  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' as any);
-
-    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: {} } as any;
-    process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
-
-    fsStatSyncSpy.mockReturnValueOnce({
-      isDirectory() {
-        return false;
-      },
-    } as any);
-
-    pathResolveSpy.mockImplementationOnce((p) => p);
-    pathRelativeSpy.mockImplementationOnce((_, p) => p);
-    pathDirnameSpy.mockImplementation((_: string) => '.');
-
-    await 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: {} } as any;
-    process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
-
-    fsStatSyncSpy.mockReturnValueOnce({
-      isDirectory() {
-        return false;
-      },
-    } as any);
-
-    pathResolveSpy.mockImplementationOnce((p) => p);
-    pathRelativeSpy.mockImplementationOnce((_, p) => p);
-    pathDirnameSpy.mockImplementation((_: string) => '.');
-
-    const result = await 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: {} } as any;
-    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';
-          },
-        } as any)
-    );
-
-    fsReaddirSyncSpy.mockImplementation((dirPath): any => {
-      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 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: {} } as any;
-    process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
-
-    await 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: {} } as any;
-    process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
-
-    fsStatSyncSpy.mockReturnValueOnce({
-      isDirectory() {
-        return false;
-      },
-    } as any);
-
-    pathResolveSpy.mockImplementationOnce((p) => p);
-    pathRelativeSpy.mockImplementationOnce((_, p) => p);
-    pathDirnameSpy.mockImplementation((_: string) => '.');
-
-    await 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: {} } as any;
-    process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
-    process.env.REDOCLY_DOMAIN = 'test-domain-from-env';
-
-    fsStatSyncSpy.mockReturnValueOnce({
-      isDirectory() {
-        return false;
-      },
-    } as any);
-
-    pathResolveSpy.mockImplementationOnce((p) => p);
-    pathRelativeSpy.mockImplementationOnce((_, p) => p);
-    pathDirnameSpy.mockImplementation((_: string) => '.');
-
-    await 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(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: {} } as any;
-    process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
-
-    remotes.push.mockRestore();
-    remotes.push.mockRejectedValueOnce(new ReuniteApiError('Deprecated.', 412));
-
-    fsStatSyncSpy.mockReturnValueOnce({
-      isDirectory() {
-        return false;
-      },
-    } as any);
-
-    pathResolveSpy.mockImplementationOnce((p) => p);
-    pathRelativeSpy.mockImplementationOnce((_, p) => p);
-    pathDirnameSpy.mockImplementation((_: string) => '.');
-
-    expect(
-      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/src/reunite/commands/__tests__/utils.test.ts

@@ -1,62 +0,0 @@
-import { retryUntilConditionMet } from '../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 retryUntilConditionMet({
-      operation,
-      condition: (result: any) => 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(
-      retryUntilConditionMet({
-        operation,
-        condition: (result: any) => 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 retryUntilConditionMet({
-      operation,
-      condition: (result: any) => result?.status === 'done',
-      retryIntervalMs: 100,
-      retryTimeoutMs: 1000,
-      onConditionNotMet,
-      onRetry,
-    });
-
-    expect(data).toEqual({ status: 'done' });
-
-    expect(onConditionNotMet).toHaveBeenCalledTimes(2);
-    expect(onRetry).toHaveBeenCalledTimes(2);
-  });
-});