@squiz/job-runner-lib 1.66.2 → 2.1.0

package/src/domains/job/services/JobUploadService/utils/manifestValidator.spec.ts

@@ -0,0 +1,213 @@
+/*!
+ * @license
+ * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
+ */
+
+import { Logger } from '@squiz/dx-logger-lib';
+import { AxiosInstance } from 'axios';
+import path from 'path';
+import { JobManifestV1, ManifestServiceForDev } from '../../../../manifest';
+import { getAndValidateManifest } from './manifestValidator';
+import { checkIfVersionExists } from './versionChecker';
+
+jest.mock('../../../../manifest', () => ({
+  ManifestServiceForDev: jest.fn(),
+  JobManifestV1: jest.fn(),
+}));
+
+jest.mock('./versionChecker', () => ({
+  checkIfVersionExists: jest.fn(),
+}));
+
+jest.mock('path', () => ({
+  join: jest.fn(),
+}));
+
+describe('manifestValidator', () => {
+  let mockLogger: Logger;
+  let mockApiClient: AxiosInstance;
+  let mockManifestService: jest.Mocked<ManifestServiceForDev>;
+  let mockManifest: jest.Mocked<JobManifestV1>;
+  const mockCheckIfVersionExists = checkIfVersionExists as jest.MockedFunction<typeof checkIfVersionExists>;
+  const mockPathJoin = path.join as jest.MockedFunction<typeof path.join>;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    mockLogger = {
+      error: jest.fn(),
+      info: jest.fn(),
+      warn: jest.fn(),
+      debug: jest.fn(),
+    } as any;
+
+    mockApiClient = {
+      get: jest.fn(),
+      post: jest.fn(),
+    } as any;
+
+    mockManifest = {
+      getName: jest.fn(),
+      getVersion: jest.fn(),
+      getModel: jest.fn(),
+    } as any;
+
+    mockManifestService = {
+      readJobManifest: jest.fn(),
+    } as any;
+
+    (ManifestServiceForDev as jest.Mock).mockImplementation(() => mockManifestService);
+  });
+
+  describe('getAndValidateManifest', () => {
+    const testFolderPath = '/test/job/folder';
+    const testManifestPath = '/test/job/folder/manifest.json';
+    const testJobName = 'test-job';
+    const testJobVersion = '1.0.0';
+
+    beforeEach(() => {
+      mockPathJoin.mockReturnValue(testManifestPath);
+      mockManifest.getName.mockReturnValue(testJobName);
+      mockManifest.getVersion.mockReturnValue(testJobVersion);
+      mockManifestService.readJobManifest.mockResolvedValue(mockManifest);
+    });
+
+    it('should successfully validate manifest when version does not exist', async () => {
+      mockCheckIfVersionExists.mockResolvedValue(false);
+
+      const result = await getAndValidateManifest(mockApiClient, testFolderPath, mockLogger);
+
+      expect(ManifestServiceForDev).toHaveBeenCalledWith(mockLogger);
+      expect(mockPathJoin).toHaveBeenCalledWith(testFolderPath, 'manifest.json');
+      expect(mockManifestService.readJobManifest).toHaveBeenCalledWith(testManifestPath);
+      expect(mockCheckIfVersionExists).toHaveBeenCalledWith(mockApiClient, `/job/${testJobName}/${testJobVersion}`);
+      expect(result).toBe(mockManifest);
+    });
+
+    it('should throw error when version already exists', async () => {
+      mockCheckIfVersionExists.mockResolvedValue(true);
+
+      await expect(getAndValidateManifest(mockApiClient, testFolderPath, mockLogger)).rejects.toThrow(
+        `Cannot upload job version, ${testJobName} ${testJobVersion} already exists`,
+      );
+
+      expect(mockManifestService.readJobManifest).toHaveBeenCalledWith(testManifestPath);
+      expect(mockCheckIfVersionExists).toHaveBeenCalledWith(mockApiClient, `/job/${testJobName}/${testJobVersion}`);
+    });
+
+    it('should handle manifest reading failure', async () => {
+      const manifestError = new Error('Failed to read manifest');
+      mockManifestService.readJobManifest.mockRejectedValue(manifestError);
+
+      await expect(getAndValidateManifest(mockApiClient, testFolderPath, mockLogger)).rejects.toThrow(
+        'Failed to read manifest',
+      );
+
+      expect(mockManifestService.readJobManifest).toHaveBeenCalledWith(testManifestPath);
+      expect(mockCheckIfVersionExists).not.toHaveBeenCalled();
+    });
+
+    it('should handle version check failure', async () => {
+      const versionCheckError = new Error('Version check failed');
+      mockCheckIfVersionExists.mockRejectedValue(versionCheckError);
+
+      await expect(getAndValidateManifest(mockApiClient, testFolderPath, mockLogger)).rejects.toThrow(
+        'Version check failed',
+      );
+
+      expect(mockManifestService.readJobManifest).toHaveBeenCalledWith(testManifestPath);
+      expect(mockCheckIfVersionExists).toHaveBeenCalledWith(mockApiClient, `/job/${testJobName}/${testJobVersion}`);
+    });
+
+    it('should handle manifest with special characters in name', async () => {
+      const specialJobName = 'test-job@special#characters';
+      const specialJobVersion = '1.0.0-beta.1';
+
+      mockManifest.getName.mockReturnValue(specialJobName);
+      mockManifest.getVersion.mockReturnValue(specialJobVersion);
+      mockCheckIfVersionExists.mockResolvedValue(false);
+
+      const result = await getAndValidateManifest(mockApiClient, testFolderPath, mockLogger);
+
+      expect(mockCheckIfVersionExists).toHaveBeenCalledWith(
+        mockApiClient,
+        `/job/${specialJobName}/${specialJobVersion}`,
+      );
+      expect(result).toBe(mockManifest);
+    });
+
+    it('should handle empty job name', async () => {
+      mockManifest.getName.mockReturnValue('');
+      mockManifest.getVersion.mockReturnValue(testJobVersion);
+      mockCheckIfVersionExists.mockResolvedValue(false);
+
+      const result = await getAndValidateManifest(mockApiClient, testFolderPath, mockLogger);
+
+      expect(mockCheckIfVersionExists).toHaveBeenCalledWith(mockApiClient, `/job//${testJobVersion}`);
+      expect(result).toBe(mockManifest);
+    });
+
+    it('should handle empty job version', async () => {
+      mockManifest.getName.mockReturnValue(testJobName);
+      mockManifest.getVersion.mockReturnValue('');
+      mockCheckIfVersionExists.mockResolvedValue(false);
+
+      const result = await getAndValidateManifest(mockApiClient, testFolderPath, mockLogger);
+
+      expect(mockCheckIfVersionExists).toHaveBeenCalledWith(mockApiClient, `/job/${testJobName}/`);
+      expect(result).toBe(mockManifest);
+    });
+
+    it('should handle different folder path formats', async () => {
+      const relativePath = './test/job';
+      const expectedManifestPath = './test/job/manifest.json';
+
+      mockPathJoin.mockReturnValue(expectedManifestPath);
+      mockCheckIfVersionExists.mockResolvedValue(false);
+
+      await getAndValidateManifest(mockApiClient, relativePath, mockLogger);
+
+      expect(mockPathJoin).toHaveBeenCalledWith(relativePath, 'manifest.json');
+      expect(mockManifestService.readJobManifest).toHaveBeenCalledWith(expectedManifestPath);
+    });
+
+    it('should handle folder path with trailing slash', async () => {
+      const folderPathWithSlash = '/test/job/folder/';
+      const expectedManifestPath = '/test/job/folder/manifest.json';
+
+      mockPathJoin.mockReturnValue(expectedManifestPath);
+      mockCheckIfVersionExists.mockResolvedValue(false);
+
+      await getAndValidateManifest(mockApiClient, folderPathWithSlash, mockLogger);
+
+      expect(mockPathJoin).toHaveBeenCalledWith(folderPathWithSlash, 'manifest.json');
+      expect(mockManifestService.readJobManifest).toHaveBeenCalledWith(expectedManifestPath);
+    });
+
+    it('should properly construct version check endpoint', async () => {
+      const complexJobName = 'my-complex_job.name';
+      const complexJobVersion = '2.1.0-rc.1';
+
+      mockManifest.getName.mockReturnValue(complexJobName);
+      mockManifest.getVersion.mockReturnValue(complexJobVersion);
+      mockCheckIfVersionExists.mockResolvedValue(false);
+
+      await getAndValidateManifest(mockApiClient, testFolderPath, mockLogger);
+
+      expect(mockCheckIfVersionExists).toHaveBeenCalledWith(
+        mockApiClient,
+        `/job/${complexJobName}/${complexJobVersion}`,
+      );
+    });
+
+    it('should handle null/undefined values from manifest', async () => {
+      mockManifest.getName.mockReturnValue(null as any);
+      mockManifest.getVersion.mockReturnValue(undefined as any);
+      mockCheckIfVersionExists.mockResolvedValue(false);
+
+      await getAndValidateManifest(mockApiClient, testFolderPath, mockLogger);
+
+      expect(mockCheckIfVersionExists).toHaveBeenCalledWith(mockApiClient, `/job/${null}/${undefined}`);
+    });
+  });
+});

package/src/domains/job/services/JobUploadService/utils/manifestValidator.ts

@@ -0,0 +1,34 @@
+/*!
+ * @license
+ * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
+ */
+
+import { Logger } from '@squiz/dx-logger-lib';
+import { AxiosInstance } from 'axios';
+import path from 'path';
+import { JobManifestV1, ManifestServiceForDev } from '../../../../manifest';
+import { checkIfVersionExists } from './versionChecker';
+
+/**
+ * Get and validate a job manifest
+ * @param apiClient - Axios client for API calls
+ * @param folderPath - Path to the job folder
+ * @param logger - Logger instance
+ * @returns The validated manifest
+ */
+export async function getAndValidateManifest(
+  apiClient: AxiosInstance,
+  folderPath: string,
+  logger: Logger,
+): Promise<JobManifestV1> {
+  const manifestService = new ManifestServiceForDev(logger);
+  const manifestPath = path.join(folderPath, 'manifest.json');
+
+  const manifest = await manifestService.readJobManifest(manifestPath);
+
+  if (await checkIfVersionExists(apiClient, `/job/${manifest.getName()}/${manifest.getVersion()}`)) {
+    throw new Error(`Cannot upload job version, ${manifest.getName()} ${manifest.getVersion()} already exists`);
+  }
+
+  return manifest;
+}

package/src/domains/job/services/JobUploadService/utils/responseHandler.spec.ts

@@ -0,0 +1,69 @@
+/*!
+ * @license
+ * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
+ */
+
+import { AxiosError, AxiosResponse } from 'axios';
+import { handleResponse, isAxiosResponse } from './responseHandler';
+
+describe('responseHandler', () => {
+  describe('handleResponse', () => {
+    it('should return data for successful 2xx responses', async () => {
+      const mockResponse: AxiosResponse = {
+        data: { message: 'Success' },
+        status: 200,
+        statusText: 'OK',
+        headers: {},
+        config: {} as any,
+      };
+
+      const responsePromise = Promise.resolve(mockResponse);
+      const result = await handleResponse(responsePromise);
+
+      expect(result).toEqual({ message: 'Success' });
+    });
+
+    it('should throw error for non-2xx responses', async () => {
+      const mockError = new AxiosError('Request failed');
+      mockError.response = {
+        data: { message: 'Not found' },
+        status: 404,
+        statusText: 'Not Found',
+        headers: {},
+        config: {} as any,
+      };
+
+      const responsePromise = Promise.reject(mockError);
+
+      await expect(handleResponse(responsePromise)).rejects.toThrow();
+    });
+
+    it('should throw error for network errors', async () => {
+      const networkError = new AxiosError('Network Error');
+      const responsePromise = Promise.reject(networkError);
+
+      await expect(handleResponse(responsePromise)).rejects.toThrow();
+    });
+  });
+
+  describe('isAxiosResponse', () => {
+    it('should return true for valid AxiosResponse objects', () => {
+      const mockResponse: AxiosResponse = {
+        data: {},
+        status: 200,
+        statusText: 'OK',
+        headers: {},
+        config: {} as any,
+      };
+
+      expect(isAxiosResponse(mockResponse)).toBe(true);
+    });
+
+    it('should return false for non-AxiosResponse objects', () => {
+      expect(isAxiosResponse({})).toBe(false);
+      expect(isAxiosResponse(null)).toBe(false);
+      expect(isAxiosResponse(undefined)).toBe(false);
+      expect(isAxiosResponse('string')).toBe(false);
+    });
+  });
+});

package/src/domains/job/services/JobUploadService/utils/responseHandler.ts

@@ -0,0 +1,33 @@
+/*!
+ * @license
+ * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
+ */
+
+import { AxiosResponse } from 'axios';
+import { handleError } from './errorUtils';
+
+/**
+ * Handle axios response and extract data
+ * @param axiosInstance - Promise resolving to axios response
+ * @returns Response data
+ */
+export async function handleResponse<T>(axiosInstance: Promise<AxiosResponse<T>>): Promise<T> {
+  try {
+    const response = await axiosInstance;
+    if (response.status.toString().startsWith('2')) {
+      return response.data;
+    }
+    throw handleError(response.data);
+  } catch (error) {
+    throw handleError(error);
+  }
+}
+
+/**
+ * Check if response is an axios response object
+ * @param response - Response to check
+ * @returns True if it's an axios response
+ */
+export function isAxiosResponse(response: any): boolean {
+  return response instanceof Object && Object.prototype.hasOwnProperty.call(response, 'status');
+}

package/src/domains/job/services/JobUploadService/utils/resultPoller.spec.ts

@@ -0,0 +1,81 @@
+/*!
+ * @license
+ * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
+ */
+
+import { Logger } from '@squiz/dx-logger-lib';
+import { AxiosInstance } from 'axios';
+import { JobManifestV1Model } from '../../../../manifest';
+import { pollForResult } from './resultPoller';
+
+jest.mock('./responseHandler', () => ({
+  handleResponse: jest.fn(),
+  isAxiosResponse: jest.fn(),
+}));
+
+jest.mock('./versionChecker', () => ({
+  checkIfVersionExists: jest.fn(),
+}));
+
+import { handleResponse, isAxiosResponse } from './responseHandler';
+
+describe('resultPoller', () => {
+  let mockApiClient: AxiosInstance;
+  let mockLogger: Logger;
+  const mockHandleResponse = handleResponse as jest.MockedFunction<typeof handleResponse>;
+  const mockIsAxiosResponse = isAxiosResponse as jest.MockedFunction<typeof isAxiosResponse>;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    mockApiClient = {
+      get: jest.fn(),
+      post: jest.fn(),
+    } as any;
+
+    mockLogger = {
+      info: jest.fn(),
+      error: jest.fn(),
+      warn: jest.fn(),
+      debug: jest.fn(),
+    } as any;
+
+    mockIsAxiosResponse.mockReturnValue(true);
+  });
+
+  describe('pollForResult', () => {
+    const testUploadId = 'upload-123';
+    const testManifest = {
+      name: 'test-job',
+      version: '1.0.0',
+    } as any as JobManifestV1Model;
+
+    it('should return result data on success', async () => {
+      const mockResult = { status: 'completed', data: 'result data' };
+      mockHandleResponse.mockResolvedValue(mockResult);
+
+      const result = await pollForResult(mockApiClient, testUploadId, testManifest, mockLogger);
+
+      expect(mockApiClient.post).toHaveBeenCalledWith('/upload-job/next', {
+        id: testUploadId,
+        manifest: testManifest,
+      });
+      expect(mockHandleResponse).toHaveBeenCalled();
+      expect(result).toEqual(mockResult);
+    });
+
+    it('should throw error when request fails', async () => {
+      const mockError = new Error('Request failed');
+      mockHandleResponse.mockRejectedValue(mockError);
+
+      await expect(pollForResult(mockApiClient, testUploadId, testManifest, mockLogger)).rejects.toThrow(
+        'Request failed',
+      );
+
+      expect(mockApiClient.post).toHaveBeenCalledWith('/upload-job/next', {
+        id: testUploadId,
+        manifest: testManifest,
+      });
+    });
+  });
+});

package/src/domains/job/services/JobUploadService/utils/resultPoller.ts

@@ -0,0 +1,52 @@
+/*!
+ * @license
+ * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
+ */
+
+import { Logger } from '@squiz/dx-logger-lib';
+import { AxiosInstance } from 'axios';
+import color from 'cli-color';
+import { JobManifestV1Model } from '../../../../manifest';
+import { handleResponse, isAxiosResponse } from './responseHandler';
+import { checkIfVersionExists } from './versionChecker';
+
+/**
+ * Poll for upload result and handle retries
+ * @param apiClient - Axios client for API calls
+ * @param uploadId - Upload ID to check
+ * @param manifest - Job manifest data
+ * @param logger - Logger instance
+ * @returns Upload result
+ */
+export async function pollForResult(
+  apiClient: AxiosInstance,
+  uploadId: string,
+  manifest: JobManifestV1Model,
+  logger: Logger,
+): Promise<any> {
+  let result = await handleResponse<any>(apiClient.post(`/upload-job/next`, { id: uploadId, manifest: manifest }));
+
+  if (!isAxiosResponse(result)) {
+    let retriesAllowed = 12;
+    while (retriesAllowed > 0) {
+      logger.info(
+        `deployment id: ${uploadId} status: ${color.yellow(
+          `unknown, retrying to check the upload status ${retriesAllowed} more times`,
+        )}`,
+      );
+      if (await checkIfVersionExists(apiClient, `/job/${manifest.name}/${manifest.version}`)) {
+        result = {
+          status: 'successful',
+        };
+        break;
+      }
+      await new Promise((r) => setTimeout(r, 10000));
+      retriesAllowed--;
+    }
+    if (retriesAllowed === 0) {
+      logger.error(`deployment id: ${uploadId} status: ${color.red('failed to check the upload status')}`);
+      throw new Error(result.toString());
+    }
+  }
+  return result;
+}

package/src/domains/job/services/JobUploadService/utils/scanWatcher.spec.ts

@@ -0,0 +1,61 @@
+/*!
+ * @license
+ * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
+ */
+
+import { AxiosInstance } from 'axios';
+import { watchAndWaitForUploadAndScanComplete } from './scanWatcher';
+
+jest.mock('./responseHandler', () => ({
+  handleResponse: jest.fn(),
+}));
+
+import { handleResponse } from './responseHandler';
+
+describe('scanWatcher', () => {
+  let mockApiClient: AxiosInstance;
+  const mockHandleResponse = handleResponse as jest.MockedFunction<typeof handleResponse>;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.useFakeTimers();
+
+    mockApiClient = {
+      get: jest.fn(),
+      post: jest.fn(),
+    } as any;
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  describe('watchAndWaitForUploadAndScanComplete', () => {
+    const testEndpoint = '/upload-job/status/';
+    const testId = 'test-id-123';
+
+    it('should resolve when status is Success', async () => {
+      mockHandleResponse.mockResolvedValue({ status: 'Success' });
+
+      await expect(watchAndWaitForUploadAndScanComplete(mockApiClient, testEndpoint, testId)).resolves.toBeUndefined();
+
+      expect(mockApiClient.get).toHaveBeenCalledWith(testEndpoint + testId);
+    });
+
+    it('should reject when status is Flagged', async () => {
+      mockHandleResponse.mockResolvedValue({ status: 'Flagged' });
+
+      await expect(watchAndWaitForUploadAndScanComplete(mockApiClient, testEndpoint, testId)).rejects.toThrow(
+        'upload has been flagged as a virus',
+      );
+    });
+
+    it('should reject when status is Error', async () => {
+      mockHandleResponse.mockResolvedValue({ status: 'Error' });
+
+      await expect(watchAndWaitForUploadAndScanComplete(mockApiClient, testEndpoint, testId)).rejects.toThrow(
+        'there has been an error',
+      );
+    });
+  });
+});

package/src/domains/job/services/JobUploadService/utils/scanWatcher.ts

@@ -0,0 +1,41 @@
+/*!
+ * @license
+ * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
+ */
+
+import { AxiosInstance } from 'axios';
+import { handleResponse } from './responseHandler';
+
+/**
+ * Watch and wait for upload and scan to complete
+ * @param apiClient - Axios client for API calls
+ * @param endpoint - API endpoint to poll
+ * @param id - Upload ID to check
+ * @returns Promise that resolves when scan is complete
+ */
+export async function watchAndWaitForUploadAndScanComplete(
+  apiClient: AxiosInstance,
+  endpoint: string,
+  id: string,
+): Promise<void> {
+  const poll = () => handleResponse<any>(apiClient.get(endpoint + id));
+
+  return new Promise((resolve, reject) => {
+    const recurse = () =>
+      poll().then(async (req) => {
+        if (req.status == 'Success') {
+          resolve();
+        } else if (req.status == 'Flagged') {
+          reject(new Error('upload has been flagged as a virus'));
+        } else if (req.status == 'Error') {
+          reject(new Error('there has been an error'));
+        } else {
+          setTimeout(async () => {
+            await recurse();
+          }, 1000);
+        }
+      });
+
+    recurse();
+  });
+}

package/src/domains/job/services/JobUploadService/utils/uploadInitializer.spec.ts

@@ -0,0 +1,106 @@
+/*!
+ * @license
+ * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
+ */
+
+import { zipDirectory } from '@squiz/dx-common-lib';
+import { Logger } from '@squiz/dx-logger-lib';
+import { AxiosInstance } from 'axios';
+import { handleResponse } from './responseHandler';
+import { initializeUpload } from './uploadInitializer';
+
+jest.mock('@squiz/dx-common-lib', () => ({
+  zipDirectory: jest.fn(),
+}));
+
+jest.mock('./responseHandler', () => ({
+  handleResponse: jest.fn(),
+}));
+
+describe('uploadInitializer', () => {
+  let mockLogger: Logger;
+  let mockApiClient: AxiosInstance;
+  const mockZipDirectory = zipDirectory as jest.MockedFunction<typeof zipDirectory>;
+  const mockHandleResponse = handleResponse as jest.MockedFunction<typeof handleResponse>;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    mockLogger = {
+      info: jest.fn(),
+      error: jest.fn(),
+      warn: jest.fn(),
+      debug: jest.fn(),
+    } as any;
+
+    mockApiClient = {
+      post: jest.fn(),
+      get: jest.fn(),
+    } as any;
+  });
+
+  describe('initializeUpload', () => {
+    const testFolderPath = '/test/folder';
+    const testTmpDir = '/tmp/test';
+    const testZipPath = '/tmp/test/job.zip';
+
+    it('should successfully initialize upload', async () => {
+      const mockUploadResponse = { id: 'upload-123', status: 'pending' };
+
+      mockZipDirectory.mockResolvedValue(testZipPath);
+      mockHandleResponse.mockResolvedValue(mockUploadResponse);
+
+      const result = await initializeUpload(mockApiClient, testFolderPath, testTmpDir, mockLogger);
+
+      expect(mockLogger.info).toHaveBeenCalledWith('Initial scanning');
+      expect(mockZipDirectory).toHaveBeenCalledWith(testFolderPath, testTmpDir);
+      expect(mockHandleResponse).toHaveBeenCalled();
+      expect(mockLogger.info).toHaveBeenCalledWith(`deployment id: ${mockUploadResponse.id} status: transferring`);
+      expect(result).toEqual({
+        zip: testZipPath,
+        upload: mockUploadResponse,
+      });
+    });
+
+    it('should handle errors during zip creation', async () => {
+      const zipError = new Error('Failed to create zip');
+      mockZipDirectory.mockRejectedValue(zipError);
+
+      await expect(initializeUpload(mockApiClient, testFolderPath, testTmpDir, mockLogger)).rejects.toThrow(
+        'Failed to create zip',
+      );
+
+      expect(mockLogger.info).toHaveBeenCalledWith('Initial scanning');
+      expect(mockZipDirectory).toHaveBeenCalledWith(testFolderPath, testTmpDir);
+      expect(mockHandleResponse).not.toHaveBeenCalled();
+    });
+
+    it('should handle errors during upload request', async () => {
+      const uploadError = new Error('Upload failed');
+      mockZipDirectory.mockResolvedValue(testZipPath);
+      mockHandleResponse.mockRejectedValue(uploadError);
+
+      await expect(initializeUpload(mockApiClient, testFolderPath, testTmpDir, mockLogger)).rejects.toThrow(
+        'Upload failed',
+      );
+
+      expect(mockZipDirectory).toHaveBeenCalledWith(testFolderPath, testTmpDir);
+      expect(mockHandleResponse).toHaveBeenCalled();
+    });
+
+    it('should handle upload response with missing id gracefully', async () => {
+      const mockUploadResponse = { status: 'pending' }; // no id property
+
+      mockZipDirectory.mockResolvedValue(testZipPath);
+      mockHandleResponse.mockResolvedValue(mockUploadResponse);
+
+      const result = await initializeUpload(mockApiClient, testFolderPath, testTmpDir, mockLogger);
+
+      expect(mockLogger.info).toHaveBeenCalledWith(`deployment id: undefined status: transferring`);
+      expect(result).toEqual({
+        zip: testZipPath,
+        upload: mockUploadResponse,
+      });
+    });
+  });
+});