refactor(semaphore): move some exceptions to global exceptions

Author: HugoMendes98

src/exceptions/concurrency.exceed-timeout.exception.ts

@@ -0,0 +1,6 @@
+import { ConcurrencyException } from "./concurrency.exception";
+
+/**
+ * When a sync class "lock" exceeds its timeout limit
+ */
+export class ConcurrencyExceedTimeoutException extends ConcurrencyException {}

src/exceptions/concurrency.invalid-timeout.exception.ts

@@ -0,0 +1,6 @@
+import { ConcurrencyException } from "./concurrency.exception";
+
+/**
+ * When an invalid value is given for a timeout
+ */
+export class ConcurrencyInvalidTimeoutException extends ConcurrencyException {}

src/exceptions/index.ts

@@ -1,2 +1,4 @@
+export * from "./concurrency.exceed-timeout.exception";
 export * from "./concurrency.exception";
 export * from "./concurrency.interrupted.exception";
+export * from "./concurrency.invalid-timeout.exception";

src/semaphore/exceptions/index.ts

@@ -1,4 +1,2 @@
-export * from "./semaphore.acquire-timeout.exception";
 export * from "./semaphore.exception";
 export * from "./semaphore.invalid-permits.exception";
-export * from "./semaphore.invalid-timeout.exception";

src/semaphore/exceptions/semaphore.acquire-timeout.exception.ts

@@ -1,11 +1,9 @@
-import {
-	SemaphoreAcquireTimeoutException,
-	SemaphoreInvalidPermitsException,
-	SemaphoreInvalidTimeoutException
-} from "./exceptions";
+import { SemaphoreInvalidPermitsException } from "./exceptions";
 import { Semaphore } from "./semaphore";
 import { timeFunction } from "../../support/time-function";
 import { ConcurrencyInterruptedException } from "../exceptions";
+import { ConcurrencyExceedTimeoutException } from "../exceptions/concurrency.exceed-timeout.exception";
+import { ConcurrencyInvalidTimeoutException } from "../exceptions/concurrency.invalid-timeout.exception";
 
 describe("Semaphore", () => {
 	describe("Constructor", () => {
@@ -44,7 +42,7 @@ describe("Semaphore", () => {
 		it("should throw a timeout exception when try-acquiring negative timeout", async () => {
 			for (const timeout of [-1, -10, -100]) {
 				await expect(() => semaphore.tryAcquire(timeout)).rejects.toThrow(
-					SemaphoreInvalidTimeoutException
+					ConcurrencyInvalidTimeoutException
 				);
 			}
 		});
@@ -222,7 +220,7 @@ describe("Semaphore", () => {
 			setTimeout(() => expect(semaphore.queueLength).toBe(1), delay / 2);
 
 			await expect(() => semaphore.tryAcquire(delay)).rejects.toThrow(
-				SemaphoreAcquireTimeoutException
+				ConcurrencyExceedTimeoutException
 			);
 
 			// The queue is reset, since the `tryAcquire` failed
@@ -245,7 +243,7 @@ describe("Semaphore", () => {
 			}, delay / 2);
 
 			await expect(() => semaphore.tryAcquire(delay, 4)).rejects.toThrow(
-				SemaphoreAcquireTimeoutException
+				ConcurrencyExceedTimeoutException
 			);
 
 			// The queue is reset, since the `tryAcquire` failed (would have been cleared even on success)

src/semaphore/exceptions/semaphore.invalid-timeout.exception.ts

@@ -1,8 +1,8 @@
+import { SemaphoreInvalidPermitsException } from "./exceptions";
 import {
-	SemaphoreAcquireTimeoutException,
-	SemaphoreInvalidPermitsException,
-	SemaphoreInvalidTimeoutException
-} from "./exceptions";
+	ConcurrencyExceedTimeoutException,
+	ConcurrencyInvalidTimeoutException
+} from "../exceptions";
 import { ConcurrencyInterruptedException } from "../exceptions";
 
 type Resolver = () => void;
@@ -107,14 +107,14 @@ export class Semaphore {
 	 *
 	 * @param timeout maximum time (in ms) to acquire the permits
 	 * @param permits The number of permits to acquire (0 acquire immediately)
-	 * @throws {SemaphoreAcquireTimeoutException} when the `timeout` value is invalid
+	 * @throws {ConcurrencyExceedTimeoutException} when the `timeout` value is invalid
 	 * @throws {SemaphoreInvalidPermitsException} when the `permits` value is invalid
 	 * @returns a promise when the permits have been acquired
 	 */
 	public tryAcquire(timeout: number, permits = 1): Promise<void> {
 		if (timeout < 0) {
 			return Promise.reject(
-				new SemaphoreInvalidTimeoutException("Cannot acquire with a negative timeout")
+				new ConcurrencyInvalidTimeoutException("Cannot acquire with a negative timeout")
 			);
 		}
 		if (permits < 0) {
@@ -150,7 +150,7 @@ export class Semaphore {
 				}
 
 				reject(
-					new SemaphoreAcquireTimeoutException(
+					new ConcurrencyExceedTimeoutException(
 						`Timeout of ${timeout}ms exceed when acquiring.`
 					)
 				);