feat: Introduce custom error types for granular error handling

Author: taj54

src/errors.ts

@@ -0,0 +1,13 @@
+export class PlatformDetectionError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'PlatformDetectionError';
+  }
+}
+
+export class VersionBumpError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'VersionBumpError';
+  }
+}

src/index.ts

@@ -10,6 +10,7 @@ import {
   PythonUpdater,
   RustUpdater,
 } from './updaters';
+import { PlatformDetectionError, VersionBumpError } from './errors';
 
 async function run() {
   try {
@@ -36,7 +37,11 @@ async function run() {
     await commitChanges(`chore: bump version to ${version}`);
     await createAndPushTag(version);
   } catch (error: unknown) {
-    if (error instanceof Error) {
+    if (error instanceof PlatformDetectionError) {
+      core.setFailed(`Platform detection failed: ${error.message}`);
+    } else if (error instanceof VersionBumpError) {
+      core.setFailed(`Version bump failed: ${error.message}`);
+    } else if (error instanceof Error) {
       core.setFailed(error.message);
     } else {
       core.setFailed(String(error));

src/services/updaterService.ts

@@ -1,5 +1,6 @@
 import semver from 'semver';
 import { Updater } from '../interface';
+import { PlatformDetectionError, VersionBumpError } from '../errors';
 
 export class UpdaterService {
   private updaters: Updater[];
@@ -10,13 +11,16 @@ export class UpdaterService {
 
   detectPlatform(): string {
     const updater = this.updaters.find((u) => u.canHandle());
-    return updater ? updater.platform : 'unknown';
+    if (!updater) {
+      throw new PlatformDetectionError('Could not detect platform.');
+    }
+    return updater.platform;
   }
 
   updateVersion(platform: string, releaseType: semver.ReleaseType): string {
     const updater = this.updaters.find((u) => u.platform === platform);
     if (!updater) {
-      throw new Error(`No updater found for platform: ${platform}`);
+      throw new VersionBumpError(`No updater found for platform: ${platform}`);
     }
     return updater.bumpVersion(releaseType);
   }

tests/services/updaterService.test.ts

@@ -0,0 +1,72 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { UpdaterService } from '../../src/services';
+import { Updater } from '../../src/interface';
+import { PlatformDetectionError, VersionBumpError } from '../../src/errors';
+
+const mockNodeUpdater: Updater = {
+  platform: 'node',
+  canHandle: vi.fn(),
+  getCurrentVersion: vi.fn(),
+  bumpVersion: vi.fn(),
+};
+
+const mockPythonUpdater: Updater = {
+  platform: 'python',
+  canHandle: vi.fn(),
+  getCurrentVersion: vi.fn(),
+  bumpVersion: vi.fn(),
+};
+
+const mockUpdaters: Updater[] = [mockNodeUpdater, mockPythonUpdater];
+
+describe('UpdaterService', () => {
+  let updaterService: UpdaterService;
+
+  beforeEach(() => {
+    updaterService = new UpdaterService(mockUpdaters);
+    vi.clearAllMocks();
+    mockNodeUpdater.canHandle.mockReset();
+    mockNodeUpdater.bumpVersion.mockReset();
+    mockPythonUpdater.canHandle.mockReset();
+    mockPythonUpdater.bumpVersion.mockReset();
+  });
+
+  describe('detectPlatform', () => {
+    it('should return the platform of the first updater that can handle', () => {
+      mockNodeUpdater.canHandle.mockReturnValue(false);
+      mockPythonUpdater.canHandle.mockReturnValue(true);
+
+      expect(updaterService.detectPlatform()).toBe('python');
+      expect(mockNodeUpdater.canHandle).toHaveBeenCalled();
+      expect(mockPythonUpdater.canHandle).toHaveBeenCalled();
+    });
+
+    it('should throw PlatformDetectionError if no updater can handle', () => {
+      mockNodeUpdater.canHandle.mockReturnValue(false);
+      mockPythonUpdater.canHandle.mockReturnValue(false);
+
+      expect(() => updaterService.detectPlatform()).toThrow(PlatformDetectionError);
+      expect(() => updaterService.detectPlatform()).toThrow('Could not detect platform.');
+    });
+  });
+
+  describe('updateVersion', () => {
+    it('should call bumpVersion on the correct updater and return the new version', () => {
+      const newVersion = '1.2.4';
+      mockNodeUpdater.bumpVersion.mockReturnValue(newVersion);
+
+      const result = updaterService.updateVersion('node', 'patch');
+
+      expect(result).toBe(newVersion);
+      expect(mockNodeUpdater.bumpVersion).toHaveBeenCalledWith('patch');
+      expect(mockPythonUpdater.bumpVersion).not.toHaveBeenCalled();
+    });
+
+    it('should throw VersionBumpError if no updater is found for the platform', () => {
+      expect(() => updaterService.updateVersion('nonexistent', 'patch')).toThrow(VersionBumpError);
+      expect(() => updaterService.updateVersion('nonexistent', 'patch')).toThrow(
+        'No updater found for platform: nonexistent',
+      );
+    });
+  });
+});