@redocly/cli 1.22.1 → 1.23.0

package/lib/utils/miscellaneous.js

@@ -50,12 +50,12 @@ const push_1 = require("../commands/push");
 const fetch_with_timeout_1 = require("./fetch-with-timeout");
 async function getFallbackApisOrExit(argsApis, config) {
     const { apis } = config;
-    const shouldFallbackToAllDefinitions = !isNotEmptyArray(argsApis) && apis && Object.keys(apis).length > 0;
+    const shouldFallbackToAllDefinitions = !(0, utils_1.isNotEmptyArray)(argsApis) && (0, utils_1.isNotEmptyObject)(apis);
     const res = shouldFallbackToAllDefinitions
         ? fallbackToAllDefinitions(apis, config)
         : await expandGlobsInEntrypoints(argsApis, config);
     const filteredInvalidEntrypoints = res.filter(({ path }) => !isApiPathValid(path));
-    if (isNotEmptyArray(filteredInvalidEntrypoints)) {
+    if ((0, utils_1.isNotEmptyArray)(filteredInvalidEntrypoints)) {
         for (const { path } of filteredInvalidEntrypoints) {
             process.stderr.write((0, colorette_1.yellow)(`\n${(0, path_1.relative)(process.cwd(), path)} ${(0, colorette_1.red)(`does not exist or is invalid.\n\n`)}`));
         }
@@ -66,9 +66,6 @@ async function getFallbackApisOrExit(argsApis, config) {
 function getConfigDirectory(config) {
     return config.configFile ? (0, path_1.dirname)(config.configFile) : process.cwd();
 }
-function isNotEmptyArray(args) {
-    return Array.isArray(args) && !!args.length;
-}
 function isApiPathValid(apiPath) {
     if (!apiPath.trim()) {
         exitWithError('Path cannot be empty.');
@@ -77,14 +74,20 @@ function isApiPathValid(apiPath) {
     return fs.existsSync(apiPath) || (0, openapi_core_1.isAbsoluteUrl)(apiPath) ? apiPath : undefined;
 }
 function fallbackToAllDefinitions(apis, config) {
-    return Object.entries(apis).map(([alias, { root }]) => ({
+    return Object.entries(apis).map(([alias, { root, output }]) => ({
         path: (0, openapi_core_1.isAbsoluteUrl)(root) ? root : (0, path_1.resolve)(getConfigDirectory(config), root),
         alias,
+        output: output && (0, path_1.resolve)(getConfigDirectory(config), output),
     }));
 }
 function getAliasOrPath(config, aliasOrPath) {
-    return config.apis[aliasOrPath]
-        ? { path: config.apis[aliasOrPath]?.root, alias: aliasOrPath }
+    const aliasApi = config.apis[aliasOrPath];
+    return aliasApi
+        ? {
+            path: aliasApi.root,
+            alias: aliasOrPath,
+            output: aliasApi.output,
+        }
         : {
             path: aliasOrPath,
             // find alias by path, take the first match
@@ -93,8 +96,8 @@ function getAliasOrPath(config, aliasOrPath) {
             })?.[0] ?? undefined,
         };
 }
-async function expandGlobsInEntrypoints(args, config) {
-    return (await Promise.all(args.map(async (aliasOrPath) => {
+async function expandGlobsInEntrypoints(argApis, config) {
+    return (await Promise.all(argApis.map(async (aliasOrPath) => {
         return glob.hasMagic(aliasOrPath) && !(0, openapi_core_1.isAbsoluteUrl)(aliasOrPath)
             ? (await (0, util_1.promisify)(glob)(aliasOrPath)).map((g) => getAliasOrPath(config, g))
             : getAliasOrPath(config, aliasOrPath);
@@ -303,28 +306,19 @@ function printConfigLintTotals(totals, command) {
         process.stderr.write((0, colorette_1.green)('✅  Your config is valid.\n'));
     }
 }
-function getOutputFileName(entrypoint, entries, output, ext) {
-    if (!output) {
-        return { outputFile: 'stdout', ext: ext || 'yaml' };
-    }
+function getOutputFileName(entrypoint, output, ext) {
     let outputFile = output;
-    if (entries > 1) {
-        ext = ext || (0, path_1.extname)(entrypoint).substring(1);
-        if (!types_1.outputExtensions.includes(ext)) {
-            throw new Error(`Invalid file extension: ${ext}.`);
-        }
-        outputFile = (0, path_1.join)(output, (0, path_1.basename)(entrypoint, (0, path_1.extname)(entrypoint))) + '.' + ext;
+    if (!outputFile) {
+        return { ext: ext || 'yaml' };
     }
-    else {
-        if (output) {
-            ext = ext || (0, path_1.extname)(output).substring(1);
-        }
-        ext = ext || (0, path_1.extname)(entrypoint).substring(1);
-        if (!types_1.outputExtensions.includes(ext)) {
-            throw new Error(`Invalid file extension: ${ext}.`);
-        }
-        outputFile = (0, path_1.join)((0, path_1.dirname)(outputFile), (0, path_1.basename)(outputFile, (0, path_1.extname)(outputFile))) + '.' + ext;
+    if (outputFile) {
+        ext = ext || (0, path_1.extname)(outputFile).substring(1);
+    }
+    ext = ext || (0, path_1.extname)(entrypoint).substring(1);
+    if (!types_1.outputExtensions.includes(ext)) {
+        throw new Error(`Invalid file extension: ${ext}.`);
     }
+    outputFile = (0, path_1.join)((0, path_1.dirname)(outputFile), (0, path_1.basename)(outputFile, (0, path_1.extname)(outputFile))) + '.' + ext;
     return { outputFile, ext };
 }
 function printUnusedWarnings(config) {
@@ -462,6 +456,7 @@ async function sendTelemetry(argv, exit_code, has_config, spec_version, spec_key
             spec_full_version,
         };
         await (0, fetch_with_timeout_1.default)(`https://api.redocly.com/registry/telemetry/cli`, {
+            timeout: fetch_with_timeout_1.DEFAULT_FETCH_TIMEOUT,
             method: 'POST',
             headers: {
                 'content-type': 'application/json',

package/lib/utils/update-version-notifier.js

@@ -32,11 +32,15 @@ exports.notifyUpdateCliVersion = notifyUpdateCliVersion;
 const isNewVersionAvailable = (current, latest) => (0, semver_1.compare)(current, latest) < 0;
 const getLatestVersion = async (packageName) => {
     const latestUrl = `http://registry.npmjs.org/${packageName}/latest`;
-    const response = await (0, fetch_with_timeout_1.default)(latestUrl);
-    if (!response)
+    try {
+        const response = await (0, fetch_with_timeout_1.default)(latestUrl, { timeout: fetch_with_timeout_1.DEFAULT_FETCH_TIMEOUT });
+        const info = await response.json();
+        return info.version;
+    }
+    catch {
+        // Do nothing
         return;
-    const info = await response.json();
-    return info.version;
+    }
 };
 const cacheLatestVersion = () => {
     if (!isNeedToBeCached() || SHOULD_NOT_NOTIFY) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redocly/cli",
-  "version": "1.22.1",
+  "version": "1.23.0",
   "description": "",
   "license": "MIT",
   "bin": {
@@ -36,7 +36,7 @@
     "Roman Hotsiy <roman@redoc.ly> (https://redoc.ly/)"
   ],
   "dependencies": {
-    "@redocly/openapi-core": "1.22.1",
+    "@redocly/openapi-core": "1.23.0",
     "abort-controller": "^3.0.0",
     "chokidar": "^3.5.1",
     "colorette": "^1.2.0",

package/src/__tests__/commands/bundle.test.ts

@@ -1,7 +1,12 @@
-import { bundle, getTotals, getMergedConfig } from '@redocly/openapi-core';
+import { bundle, getTotals, getMergedConfig, Config } from '@redocly/openapi-core';
 
 import { BundleOptions, handleBundle } from '../../commands/bundle';
-import { handleError } from '../../utils/miscellaneous';
+import {
+  getFallbackApisOrExit,
+  getOutputFileName,
+  handleError,
+  saveBundle,
+} from '../../utils/miscellaneous';
 import { commandWrapper } from '../../wrapper';
 import SpyInstance = jest.SpyInstance;
 import { Arguments } from 'yargs';
@@ -9,24 +14,31 @@ import { Arguments } from 'yargs';
 jest.mock('@redocly/openapi-core');
 jest.mock('../../utils/miscellaneous');
 
+// @ts-ignore
+getOutputFileName = jest.requireActual('../../utils/miscellaneous').getOutputFileName;
+
 (getMergedConfig as jest.Mock).mockImplementation((config) => config);
 
 describe('bundle', () => {
   let processExitMock: SpyInstance;
   let exitCb: any;
-
+  let stderrWriteMock: any;
+  let stdoutWriteMock: any;
   beforeEach(() => {
     processExitMock = jest.spyOn(process, 'exit').mockImplementation();
     jest.spyOn(process, 'once').mockImplementation((_e, cb) => {
       exitCb = cb;
       return process.on(_e, cb);
     });
-    jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+    stderrWriteMock = jest.spyOn(process.stderr, 'write').mockImplementation(jest.fn());
+    stdoutWriteMock = jest.spyOn(process.stdout, 'write').mockImplementation(jest.fn());
   });
 
   afterEach(() => {
     (bundle as jest.Mock).mockClear();
     (getTotals as jest.Mock).mockReset();
+    stderrWriteMock.mockRestore();
+    stdoutWriteMock.mockRestore();
   });
 
   it('bundles definitions', async () => {
@@ -114,4 +126,119 @@ describe('bundle', () => {
 
     expect(handleError).toHaveBeenCalledTimes(0);
   });
+
+  it('should store bundled API descriptions in the output files described in the apis section of config IF no positional apis provided AND output is specified for both apis', async () => {
+    const apis = {
+      foo: {
+        root: 'foo.yaml',
+        output: 'output/foo.yaml',
+      },
+      bar: {
+        root: 'bar.yaml',
+        output: 'output/bar.json',
+      },
+    };
+    const config = {
+      apis,
+      styleguide: {
+        skipPreprocessors: jest.fn(),
+        skipDecorators: jest.fn(),
+      },
+    } as unknown as Config;
+    // @ts-ignore
+    getFallbackApisOrExit = jest
+      .fn()
+      .mockResolvedValueOnce(
+        Object.entries(apis).map(([alias, { root, ...api }]) => ({ ...api, path: root, alias }))
+      );
+    (getTotals as jest.Mock).mockReturnValue({
+      errors: 0,
+      warnings: 0,
+      ignored: 0,
+    });
+
+    await handleBundle({
+      argv: { apis: [] }, // positional
+      version: 'test',
+      config,
+    });
+
+    expect(saveBundle).toBeCalledTimes(2);
+    expect(saveBundle).toHaveBeenNthCalledWith(1, 'output/foo.yaml', expect.any(String));
+    expect(saveBundle).toHaveBeenNthCalledWith(2, 'output/bar.json', expect.any(String));
+  });
+
+  it('should store bundled API descriptions in the output files described in the apis section of config AND print the bundled api without the output specified to the terminal IF no positional apis provided AND output is specified for one api', async () => {
+    const apis = {
+      foo: {
+        root: 'foo.yaml',
+        output: 'output/foo.yaml',
+      },
+      bar: {
+        root: 'bar.yaml',
+      },
+    };
+    const config = {
+      apis,
+      styleguide: {
+        skipPreprocessors: jest.fn(),
+        skipDecorators: jest.fn(),
+      },
+    } as unknown as Config;
+    // @ts-ignore
+    getFallbackApisOrExit = jest
+      .fn()
+      .mockResolvedValueOnce(
+        Object.entries(apis).map(([alias, { root, ...api }]) => ({ ...api, path: root, alias }))
+      );
+    (getTotals as jest.Mock).mockReturnValue({
+      errors: 0,
+      warnings: 0,
+      ignored: 0,
+    });
+
+    await handleBundle({
+      argv: { apis: [] }, // positional
+      version: 'test',
+      config,
+    });
+
+    expect(saveBundle).toBeCalledTimes(1);
+    expect(saveBundle).toHaveBeenCalledWith('output/foo.yaml', expect.any(String));
+    expect(process.stdout.write).toHaveBeenCalledTimes(1);
+  });
+
+  describe('per api output', () => {
+    it('should NOT store bundled API descriptions in the output files described in the apis section of config IF no there is a positional api provided', async () => {
+      const apis = {
+        foo: {
+          root: 'foo.yaml',
+          output: 'output/foo.yaml',
+        },
+      };
+      const config = {
+        apis,
+        styleguide: {
+          skipPreprocessors: jest.fn(),
+          skipDecorators: jest.fn(),
+        },
+      } as unknown as Config;
+      // @ts-ignore
+      getFallbackApisOrExit = jest.fn().mockResolvedValueOnce([{ path: 'openapi.yaml' }]);
+      (getTotals as jest.Mock).mockReturnValue({
+        errors: 0,
+        warnings: 0,
+        ignored: 0,
+      });
+
+      await handleBundle({
+        argv: { apis: ['openapi.yaml'] }, // positional
+        version: 'test',
+        config,
+      });
+
+      expect(saveBundle).toBeCalledTimes(0);
+      expect(process.stdout.write).toHaveBeenCalledTimes(1);
+    });
+  });
 });

package/src/__tests__/fetch-with-timeout.test.ts

@@ -1,23 +1,53 @@
 import AbortController from 'abort-controller';
 import fetchWithTimeout from '../utils/fetch-with-timeout';
 import nodeFetch from 'node-fetch';
+import { getProxyAgent } from '@redocly/openapi-core';
+import { HttpsProxyAgent } from '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(() => {
+    (getProxyAgent as jest.Mock).mockReturnValueOnce(undefined);
+  });
+
   afterEach(() => {
     jest.clearAllMocks();
   });
 
   it('should call node-fetch with signal', async () => {
-    // @ts-ignore
-    global.setTimeout = jest.fn();
-
-    global.clearTimeout = jest.fn();
-    await fetchWithTimeout('url');
+    await fetchWithTimeout('url', { timeout: 1000 });
 
     expect(global.setTimeout).toHaveBeenCalledTimes(1);
-    expect(nodeFetch).toHaveBeenCalledWith('url', { signal: new AbortController().signal });
+    expect(nodeFetch).toHaveBeenCalledWith('url', {
+      signal: new AbortController().signal,
+      agent: undefined,
+    });
     expect(global.clearTimeout).toHaveBeenCalledTimes(1);
   });
+
+  it('should call node-fetch with proxy agent', async () => {
+    (getProxyAgent as jest.Mock).mockRestore();
+    const proxyAgent = new HttpsProxyAgent('http://localhost');
+    (getProxyAgent as jest.Mock).mockReturnValueOnce(proxyAgent);
+
+    await fetchWithTimeout('url');
+
+    expect(nodeFetch).toHaveBeenCalledWith('url', { agent: proxyAgent });
+  });
+
+  it('should call node-fetch without signal when timeout is not passed', async () => {
+    await fetchWithTimeout('url');
+
+    expect(global.setTimeout).not.toHaveBeenCalled();
+    expect(nodeFetch).toHaveBeenCalledWith('url', { agent: undefined });
+    expect(global.clearTimeout).not.toHaveBeenCalled();
+  });
 });

package/src/__tests__/utils.test.ts

@@ -27,6 +27,7 @@ import { blue, red, yellow } from 'colorette';
 import { existsSync, statSync } from 'fs';
 import * as path from 'path';
 import * as process from 'process';
+import { ConfigApis } from '../types';
 
 jest.mock('os');
 jest.mock('colorette');
@@ -79,20 +80,6 @@ describe('pathToFilename', () => {
   });
 });
 
-describe('getFallbackApisOrExit', () => {
-  it('should find alias by filename', async () => {
-    (existsSync as jest.Mock<any, any>).mockImplementationOnce(() => true);
-    const entry = await getFallbackApisOrExit(['./test.yaml'], {
-      apis: {
-        main: {
-          root: 'test.yaml',
-        },
-      },
-    } as any);
-    expect(entry).toEqual([{ path: './test.yaml', alias: 'main' }]);
-  });
-});
-
 describe('printConfigLintTotals', () => {
   const totalProblemsMock: Totals = {
     errors: 1,
@@ -190,6 +177,7 @@ describe('getFallbackApisOrExit', () => {
       {
         alias: 'main',
         path: 'someFile.yaml',
+        output: undefined,
       },
     ]);
   });
@@ -277,6 +265,43 @@ describe('getFallbackApisOrExit', () => {
       {
         alias: 'main',
         path: 'https://someLinkt/petstore.yaml?main',
+        output: undefined,
+      },
+    ]);
+
+    (isAbsoluteUrl as jest.Mock<any, any>).mockReset();
+  });
+
+  it('should find alias by filename', async () => {
+    (existsSync as jest.Mock<any, any>).mockImplementationOnce(() => true);
+    const entry = await getFallbackApisOrExit(['./test.yaml'], {
+      apis: {
+        main: {
+          root: 'test.yaml',
+          styleguide: {},
+        },
+      },
+    });
+    expect(entry).toEqual([{ path: './test.yaml', alias: 'main' }]);
+  });
+
+  it('should return apis from config with paths and outputs resolved relatively to the config location', async () => {
+    (existsSync as jest.Mock<any, any>).mockImplementationOnce(() => true);
+    const entry = await getFallbackApisOrExit(undefined, {
+      apis: {
+        main: {
+          root: 'test.yaml',
+          output: 'output/test.yaml',
+          styleguide: {},
+        },
+      },
+      configFile: 'project-folder/redocly.yaml',
+    });
+    expect(entry).toEqual([
+      {
+        path: expect.stringMatching(/project\-folder\/test\.yaml$/),
+        output: expect.stringMatching(/project\-folder\/output\/test\.yaml$/),
+        alias: 'main',
       },
     ]);
   });
@@ -591,28 +616,28 @@ describe('cleanRawInput', () => {
       expect(stderrMock).toHaveBeenCalledWith(`Unsupported file extension: xml. Using yaml.\n`);
     });
   });
+});
 
-  describe('writeToFileByExtension', () => {
-    beforeEach(() => {
-      jest.spyOn(process.stderr, 'write').mockImplementation(jest.fn());
-      (yellow as jest.Mock<any, any>).mockImplementation((text: string) => text);
-    });
+describe('writeToFileByExtension', () => {
+  beforeEach(() => {
+    jest.spyOn(process.stderr, 'write').mockImplementation(jest.fn());
+    (yellow as jest.Mock<any, any>).mockImplementation((text: string) => text);
+  });
 
-    afterEach(() => {
-      jest.restoreAllMocks();
-    });
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
 
-    it('should call stringifyYaml function', () => {
-      writeToFileByExtension('test data', 'test.yaml');
-      expect(stringifyYaml).toHaveBeenCalledWith('test data', { noRefs: false });
-      expect(process.stderr.write).toHaveBeenCalledWith(`test data`);
-    });
+  it('should call stringifyYaml function', () => {
+    writeToFileByExtension('test data', 'test.yaml');
+    expect(stringifyYaml).toHaveBeenCalledWith('test data', { noRefs: false });
+    expect(process.stderr.write).toHaveBeenCalledWith(`test data`);
+  });
 
-    it('should call JSON.stringify function', () => {
-      const stringifySpy = jest.spyOn(JSON, 'stringify').mockImplementation((data) => data);
-      writeToFileByExtension('test data', 'test.json');
-      expect(stringifySpy).toHaveBeenCalledWith('test data', null, 2);
-      expect(process.stderr.write).toHaveBeenCalledWith(`test data`);
-    });
+  it('should call JSON.stringify function', () => {
+    const stringifySpy = jest.spyOn(JSON, 'stringify').mockImplementation((data) => data);
+    writeToFileByExtension('test data', 'test.json');
+    expect(stringifySpy).toHaveBeenCalledWith('test data', null, 2);
+    expect(process.stderr.write).toHaveBeenCalledWith(`test data`);
   });
 });

package/src/cms/api/__tests__/api.client.test.ts

@@ -1,7 +1,7 @@
 import fetch, { Response } from 'node-fetch';
 import * as FormData from 'form-data';
 
-import { ReuniteApiClient, PushPayload } from '../api-client';
+import { ReuniteApiClient, PushPayload, ReuniteApiError } from '../api-client';
 
 jest.mock('node-fetch', () => ({
   default: jest.fn(),
@@ -16,12 +16,15 @@ describe('ApiClient', () => {
   const testDomain = 'test-domain.com';
   const testOrg = 'test-org';
   const testProject = 'test-project';
+  const version = '1.0.0';
+  const command = 'push';
+  const expectedUserAgent = `redocly-cli/${version} ${command}`;
 
   describe('getDefaultBranch()', () => {
     let apiClient: ReuniteApiClient;
 
     beforeEach(() => {
-      apiClient = new ReuniteApiClient(testDomain, testToken);
+      apiClient = new ReuniteApiClient({ domain: testDomain, apiKey: testToken, version, command });
     });
 
     it('should get default project branch', async () => {
@@ -41,6 +44,7 @@ describe('ApiClient', () => {
           headers: {
             'Content-Type': 'application/json',
             Authorization: `Bearer ${testToken}`,
+            'user-agent': expectedUserAgent,
           },
           signal: expect.any(Object),
         }
@@ -62,7 +66,7 @@ describe('ApiClient', () => {
       });
 
       await expect(apiClient.remotes.getDefaultBranch(testOrg, testProject)).rejects.toThrow(
-        new Error('Failed to fetch default branch: Project source not found')
+        new ReuniteApiError('Failed to fetch default branch. Project source not found.', 404)
       );
     });
 
@@ -76,7 +80,7 @@ describe('ApiClient', () => {
       });
 
       await expect(apiClient.remotes.getDefaultBranch(testOrg, testProject)).rejects.toThrow(
-        new Error('Failed to fetch default branch: Not found')
+        new ReuniteApiError('Failed to fetch default branch. Not found.', 404)
       );
     });
   });
@@ -89,7 +93,7 @@ describe('ApiClient', () => {
     let apiClient: ReuniteApiClient;
 
     beforeEach(() => {
-      apiClient = new ReuniteApiClient(testDomain, testToken);
+      apiClient = new ReuniteApiClient({ domain: testDomain, apiKey: testToken, version, command });
     });
 
     it('should upsert remote', async () => {
@@ -116,6 +120,7 @@ describe('ApiClient', () => {
           headers: {
             'Content-Type': 'application/json',
             Authorization: `Bearer ${testToken}`,
+            'user-agent': expectedUserAgent,
           },
           body: JSON.stringify({
             mountPath: remotePayload.mountPath,
@@ -144,8 +149,9 @@ describe('ApiClient', () => {
       });
 
       await expect(apiClient.remotes.upsert(testOrg, testProject, remotePayload)).rejects.toThrow(
-        new Error(
-          'Failed to upsert remote: Not allowed to mount remote outside of project content path: /docs'
+        new ReuniteApiError(
+          'Failed to upsert remote. Not allowed to mount remote outside of project content path: /docs.',
+          403
         )
       );
     });
@@ -153,6 +159,7 @@ describe('ApiClient', () => {
     it('should throw statusText error if response is not ok', async () => {
       mockFetchResponse({
         ok: false,
+        status: 404,
         statusText: 'Not found',
         json: jest.fn().mockResolvedValue({
           unknownField: 'unknown-error',
@@ -160,7 +167,7 @@ describe('ApiClient', () => {
       });
 
       await expect(apiClient.remotes.upsert(testOrg, testProject, remotePayload)).rejects.toThrow(
-        new Error('Failed to upsert remote: Not found')
+        new ReuniteApiError('Failed to upsert remote. Not found.', 404)
       );
     });
   });
@@ -200,7 +207,7 @@ describe('ApiClient', () => {
     let apiClient: ReuniteApiClient;
 
     beforeEach(() => {
-      apiClient = new ReuniteApiClient(testDomain, testToken);
+      apiClient = new ReuniteApiClient({ domain: testDomain, apiKey: testToken, version, command });
     });
 
     it('should push to remote', async () => {
@@ -234,6 +241,7 @@ describe('ApiClient', () => {
           method: 'POST',
           headers: {
             Authorization: `Bearer ${testToken}`,
+            'user-agent': expectedUserAgent,
           },
         })
       );
@@ -258,12 +266,13 @@ describe('ApiClient', () => {
 
       await expect(
         apiClient.remotes.push(testOrg, testProject, pushPayload, filesMock)
-      ).rejects.toThrow(new Error('Failed to push: Cannot push to remote'));
+      ).rejects.toThrow(new ReuniteApiError('Failed to push. Cannot push to remote.', 403));
     });
 
     it('should throw statusText error if response is not ok', async () => {
       mockFetchResponse({
         ok: false,
+        status: 404,
         statusText: 'Not found',
         json: jest.fn().mockResolvedValue({
           unknownField: 'unknown-error',
@@ -272,7 +281,7 @@ describe('ApiClient', () => {
 
       await expect(
         apiClient.remotes.push(testOrg, testProject, pushPayload, filesMock)
-      ).rejects.toThrow(new Error('Failed to push: Not found'));
+      ).rejects.toThrow(new ReuniteApiError('Failed to push. Not found.', 404));
     });
   });
 });