Refactor access modifiers in ffmpeg.ts and jimp.ts

Author: Thavarshan

src/lib/conversion/conversion-handler.ts

@@ -5,14 +5,15 @@ import { AudioFormat } from '@/enum/audio-format';
 import { ImageFormat } from '@/enum/image-format';
 import { FfmpegAdapter } from './ffmpeg';
 import { JimpAdapter } from './jimp';
+import { Adapter } from '@/types/adapter';
 
 export class ConversionHandler {
-  protected conversions: Map<string, FfmpegAdapter | JimpAdapter> = new Map();
+  protected conversions: Map<string, Adapter> = new Map();
 
   /**
    * Adds a new conversion to the handler.
    */
-  handle(
+  async handle(
     id: string,
     filePath: string,
     outputFormat: VideoFormat | AudioFormat | ImageFormat,
@@ -22,28 +23,32 @@ export class ConversionHandler {
   ): Promise<string> {
     const adapter = this.getAdapter(type);
 
-    return new Promise((resolve, reject) => {
-      this.conversions.set(id, adapter);
+    this.conversions.set(id, adapter);
 
-      adapter
-        .convert(id, filePath, outputFormat, saveDirectory, event)
-        .then(() => {
-          this.conversions.delete(id);
-          resolve(filePath);
-        })
-        .catch((error) => {
-          this.conversions.delete(id);
-          reject(error);
-        });
-    });
+    try {
+      const result = await adapter.convert(id, filePath, outputFormat, saveDirectory, event);
+
+      this.conversions.delete(id);
+
+      return result;
+    } catch (error) {
+      this.conversions.delete(id);
+
+      throw error;
+    }
   }
 
   /**
    * Cancels the conversion with the given ID.
    */
   cancel(id: string): boolean {
     const adapter = this.conversions.get(id);
-    return adapter ? adapter.cancel(id) : false;
+    if (adapter) {
+      const result = adapter.cancel(id);
+      this.conversions.delete(id);
+      return result;
+    }
+    return false;
   }
 
   /**

src/lib/conversion/ffmpeg.ts

@@ -20,7 +20,7 @@ export class FfmpegAdapter implements Adapter {
   /**
    * Map of FFmpeg processes by ID.
    */
-  private ffmpegProcesses = new Map<string, ffmpeg.FfmpegCommand>();
+  protected ffmpegProcesses = new Map<string, ffmpeg.FfmpegCommand>();
 
   /**
    * Converts the file at the given path to the specified output format.

src/lib/conversion/jimp.ts

@@ -6,7 +6,7 @@ import { Adapter } from '@/types/adapter';
 export type JimpType = typeof Jimp;
 
 export class JimpAdapter implements Adapter {
-  private jimpProcesses = new Map<string, JimpType>();
+  protected jimpProcesses = new Map<string, JimpType>();
 
   /**
    * Converts the file at the given path to the specified output format.
@@ -21,7 +21,6 @@ export class JimpAdapter implements Adapter {
     const outputFileName = `${path.basename(filePath, path.extname(filePath))}.${outputFormat}`;
     const outputPath = path.join(saveDirectory, outputFileName);
 
-    // Ensure save directory exists
     await fs.mkdir(saveDirectory, { recursive: true });
 
     const image = await Jimp.read(filePath);

src/lib/system/ipc-handlers.ts

@@ -42,17 +42,11 @@ export function configureIpcHandlers(ipcMain: IpcMain): void {
         mediaType: Media;
       },
     ) => {
-      return new Promise<string>((resolve, reject) => {
-        conversionHandler
-          .handle(id, filePath, outputFormat, saveDirectory, mediaType, event)
-          .then(resolve)
-          .catch(reject);
-      });
+      return await conversionHandler.handle(id, filePath, outputFormat, saveDirectory, mediaType, event);
     },
   );
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  ipcMain.handle(IpcEvent.CANCEL_CONVERSION, (_event: IpcMainInvokeEvent) => {
+  ipcMain.handle(IpcEvent.CANCEL_CONVERSION, () => {
     return conversionHandler.cancelAll();
   });
 

tests/main/conversion-handler.test.ts

@@ -96,16 +96,18 @@ describe('ConversionHandler', () => {
     });
 
     test('should reject unsupported media type', async () => {
-      await expect(
-        conversionHandler.handle(
+      try {
+        await conversionHandler.handle(
           '1',
           '/mock/path/unknown.file',
           'unknown_format' as VideoFormat,
           '/mock/save',
           'unknown' as Media,
           mockEvent
-        )
-      ).rejects.toThrow('Unsupported type: unknown');
+        );
+      } catch (error) {
+        expect(error).toEqual(new Error('Unsupported type: unknown'));
+      }
     });
 
     test('should handle conversion failure', async () => {
@@ -137,7 +139,8 @@ describe('ConversionHandler', () => {
       const mockJimpAdapter = jest.spyOn(JimpAdapter.prototype, 'cancel').mockReturnValue(true);
 
       // Mock the process is already stored in the map
-      conversionHandler['conversions'].set('1', new JimpAdapter());
+      const jimpAdapterInstance = new JimpAdapter();
+      conversionHandler['conversions'].set('1', jimpAdapterInstance);
 
       const result = conversionHandler.cancel('1');
 

tests/main/ipc-handler.test.ts

@@ -1,141 +1,133 @@
-/**
- * @jest-environment node
- */
-
-import { configureIpcHandlers } from '../../src/lib/system/ipc-handlers';
-import { IpcEvent } from '../../src/enum/ipc-event';
-import { dialog, ipcMain, IpcMainInvokeEvent } from 'electron';
-import { getDesktopPath } from '../../src/lib/utils/desktop-path';
-import { ConversionHandler } from '../../src/lib/conversion/conversion-handler';
-
-jest.mock('../../src/lib/utils/desktop-path');
-jest.mock('../../src/lib/conversion/conversion-handler');
+import { dialog, IpcMainInvokeEvent } from 'electron';
+import { getDesktopPath } from '@/lib/utils/desktop-path';
+import { IpcEvent } from '@/enum/ipc-event';
+import { ConversionHandler } from '@/lib/conversion/conversion-handler';
+import { configureIpcHandlers } from '@/lib/system/ipc-handlers';
+
+// Mock the dependencies
+jest.mock('electron', () => ({
+  dialog: {
+    showOpenDialog: jest.fn(),
+  },
+}));
+jest.mock('@/lib/utils/desktop-path', () => ({
+  getDesktopPath: jest.fn(),
+}));
+jest.mock('@/lib/conversion/conversion-handler', () => {
+  return {
+    ConversionHandler: jest.fn().mockImplementation(() => ({
+      handle: jest.fn(),
+      cancelAll: jest.fn(),
+      cancel: jest.fn(),
+    })),
+  };
+});
 
 describe('configureIpcHandlers', () => {
-  let mockConversionHandler: jest.Mocked<ConversionHandler>;
+  let ipcMainMock: any;
+  let conversionHandlerMock: any;
 
   beforeEach(() => {
-    jest.resetAllMocks();
-    mockConversionHandler = new ConversionHandler() as jest.Mocked<ConversionHandler>;
-  });
+    ipcMainMock = {
+      handle: jest.fn(),
+    };
 
-  afterEach(() => {
-    ipcMain.removeAllListeners();
+    jest.clearAllMocks();
+    conversionHandlerMock = new ConversionHandler();
   });
 
-  test('should handle GET_DESKTOP_PATH', async () => {
-    const mockGetDesktopPath = jest.mocked(getDesktopPath);
-    mockGetDesktopPath.mockReturnValue('/mock/desktop/path');
+  it('should handle GET_DESKTOP_PATH and call getDesktopPath()', () => {
+    configureIpcHandlers(ipcMainMock);
 
-    configureIpcHandlers(ipcMain);
+    const mockGetDesktopPath = getDesktopPath as jest.Mock;
+    mockGetDesktopPath.mockReturnValue('/path/to/desktop');
 
-    const handler = (ipcMain.handle as jest.Mock).mock.calls.find(
-      ([event]) => event === IpcEvent.GET_DESKTOP_PATH
-    )[1];
+    const handler = ipcMainMock.handle.mock.calls.find((call: any) => call[0] === IpcEvent.GET_DESKTOP_PATH)[1];
+    handler();
 
-    const result = await handler();
-
-    expect(result).toBe('/mock/desktop/path');
     expect(mockGetDesktopPath).toHaveBeenCalled();
   });
 
-  test('should handle DIALOG_SELECT_DIRECTORY', async () => {
-    const mockShowOpenDialog = jest.mocked(dialog.showOpenDialog);
-    mockShowOpenDialog.mockResolvedValue({ canceled: false, filePaths: ['/mock/directory'] });
-
-    configureIpcHandlers(ipcMain);
+  it('should handle DIALOG_SELECT_DIRECTORY and call dialog.showOpenDialog()', async () => {
+    configureIpcHandlers(ipcMainMock);
 
-    const handler = (ipcMain.handle as jest.Mock).mock.calls.find(
-      ([event]) => event === IpcEvent.DIALOG_SELECT_DIRECTORY
-    )[1];
+    const dialogMock = dialog.showOpenDialog as jest.Mock;
+    dialogMock.mockResolvedValue({ canceled: false, filePaths: ['/path/to/directory'] });
 
+    const handler = ipcMainMock.handle.mock.calls.find((call: any) => call[0] === IpcEvent.DIALOG_SELECT_DIRECTORY)[1];
     const result = await handler();
 
-    expect(result).toBe('/mock/directory');
-    expect(mockShowOpenDialog).toHaveBeenCalledWith({
-      properties: ['openDirectory'],
-    });
+    expect(dialogMock).toHaveBeenCalledWith({ properties: ['openDirectory'] });
+    expect(result).toBe('/path/to/directory');
   });
 
-  test('should handle DIALOG_SELECT_DIRECTORY cancellation', async () => {
-    const mockShowOpenDialog = jest.mocked(dialog.showOpenDialog);
-    mockShowOpenDialog.mockResolvedValue({ canceled: true, filePaths: [] });
+  it('should return null if directory selection is canceled', async () => {
+    configureIpcHandlers(ipcMainMock);
 
-    configureIpcHandlers(ipcMain);
-
-    const handler = (ipcMain.handle as jest.Mock).mock.calls.find(
-      ([event]) => event === IpcEvent.DIALOG_SELECT_DIRECTORY
-    )[1];
+    const dialogMock = dialog.showOpenDialog as jest.Mock;
+    dialogMock.mockResolvedValue({ canceled: true, filePaths: [] });
 
+    const handler = ipcMainMock.handle.mock.calls.find((call: any) => call[0] === IpcEvent.DIALOG_SELECT_DIRECTORY)[1];
     const result = await handler();
 
+    expect(dialogMock).toHaveBeenCalledWith({ properties: ['openDirectory'] });
     expect(result).toBeNull();
-    expect(mockShowOpenDialog).toHaveBeenCalledWith({
-      properties: ['openDirectory'],
-    });
   });
 
-  test('should handle CONVERT_MEDIA', async () => {
-    // Make sure the mocked conversion handler returns a resolved promise
-    mockConversionHandler.handle.mockResolvedValue('/mock/output/path');
-
-    configureIpcHandlers(ipcMain);
-
-    const handler = (ipcMain.handle as jest.Mock).mock.calls.find(
-      ([event]) => event === IpcEvent.CONVERT_MEDIA
-    )[1];
-
-    const result = await handler(
-      {} as IpcMainInvokeEvent,
-      {
-        id: '1',
-        filePath: '/mock/path/video.mp4',
-        outputFormat: 'mp4',
-        saveDirectory: '/mock/save',
-        mediaType: 'video',
-      }
-    );
+  it('should handle CONVERT_MEDIA and call conversionHandler.handle()', async () => {
+    configureIpcHandlers(ipcMainMock);
 
-    expect(result).toBe('/mock/output/path');
-    expect(mockConversionHandler.handle).toHaveBeenCalledWith(
+    const mockHandle = conversionHandlerMock.handle as jest.Mock;
+    mockHandle.mockResolvedValue('conversion-success');
+
+    const handler = ipcMainMock.handle.mock.calls.find((call: any) => call[0] === IpcEvent.CONVERT_MEDIA)[1];
+
+    console.log(handler);
+
+
+    const mockEvent = {} as IpcMainInvokeEvent;
+    const mediaParams = {
+      id: '1',
+      filePath: '/path/to/file',
+      outputFormat: 'mp4',
+      saveDirectory: '/path/to/save',
+      mediaType: 'video',
+    };
+
+    const result = await handler(mockEvent, mediaParams);
+
+    expect(mockHandle).toHaveBeenCalledWith(
       '1',
-      '/mock/path/video.mp4',
+      '/path/to/file',
       'mp4',
-      '/mock/save',
+      '/path/to/save',
       'video',
-      expect.any(Object)
+      mockEvent
     );
+    expect(result).toBe('conversion-success');
   });
 
-  test('should handle CANCEL_ITEM_CONVERSION', () => {
-    // Mock the cancel method to return true
-    mockConversionHandler.cancel.mockReturnValue(true);
+  it('should handle CANCEL_CONVERSION and call conversionHandler.cancelAll()', () => {
+    configureIpcHandlers(ipcMainMock);
 
-    configureIpcHandlers(ipcMain);
+    const mockCancelAll = conversionHandlerMock.cancelAll as jest.Mock;
 
-    const handler = (ipcMain.handle as jest.Mock).mock.calls.find(
-      ([event]) => event === IpcEvent.CANCEL_ITEM_CONVERSION
-    )[1];
+    const handler = ipcMainMock.handle.mock.calls.find((call: any) => call[0] === IpcEvent.CANCEL_CONVERSION)[1];
+    const result = handler();
 
-    const result = handler({} as IpcMainInvokeEvent, '1');
-
-    expect(result).toBe(true);
-    expect(mockConversionHandler.cancel).toHaveBeenCalledWith('1');
+    expect(mockCancelAll).toHaveBeenCalled();
+    expect(result).toBe('cancel-all-success');
   });
 
-  test('should handle CANCEL_CONVERSION', () => {
-    // Ensure cancelAll doesn't return undefined but behaves as expected
-    mockConversionHandler.cancelAll.mockImplementation(() => true);
-
-    configureIpcHandlers(ipcMain);
+  it('should handle CANCEL_ITEM_CONVERSION and call conversionHandler.cancel()', () => {
+    configureIpcHandlers(ipcMainMock);
 
-    const handler = (ipcMain.handle as jest.Mock).mock.calls.find(
-      ([event]) => event === IpcEvent.CANCEL_CONVERSION
-    )[1];
+    const mockCancel = conversionHandlerMock.cancel as jest.Mock;
 
-    const result = handler({} as IpcMainInvokeEvent);
+    const handler = ipcMainMock.handle.mock.calls.find((call: any) => call[0] === IpcEvent.CANCEL_ITEM_CONVERSION)[1];
+    const result = handler({}, '1');
 
-    expect(result).toBe(true);
-    expect(mockConversionHandler.cancelAll).toHaveBeenCalled();
+    expect(mockCancel).toHaveBeenCalledWith('1');
+    expect(result).toBe('cancel-item-success');
   });
 });