Merge pull request #10 from heap-code/fix/2-lock-with

fix(ci): set runInBand when testing

Author: HugoMendes98

package.json

@@ -76,10 +76,10 @@
 		"compodoc:coverage": "npm run compodoc:build -- --coverageTest 80",
 		"lint": "eslint .",
 		"lint:fix": "npm run lint -- --fix",
-		"test": "jest --config jest.config.ts",
+		"test": "jest --config jest.config.ts --runInBand",
 		"test:coverage": "npm run test -- --coverage",
 		"test:watch": "npm run test -- --watch"
 	},
 	"types": "./dist/types/index.js",
-	"version": "0.2.0"
+	"version": "0.2.1"
 }

src/mutex/mutex.spec.ts

@@ -8,8 +8,9 @@ import {
 } from "../exceptions";
 
 describe("Mutex", () => {
-	const delay = 50;
-	const offset = 5;
+	const delay = 60;
+	const offsetLow = 5;
+	const offset = 15;
 
 	describe("Input validation", () => {
 		const mutex = new Mutex();
@@ -50,7 +51,7 @@ describe("Mutex", () => {
 			mutex.unlock();
 			expect(mutex.isLocked).toBeFalse();
 
-			expect(elapsed).toBeGreaterThanOrEqual(delay - offset);
+			expect(elapsed).toBeGreaterThanOrEqual(delay - offsetLow);
 			expect(elapsed).toBeLessThanOrEqual(delay + offset);
 		});
 
@@ -100,15 +101,15 @@ describe("Mutex", () => {
 				.map(([elapsed]) => elapsed)
 				.sort((a, b) => a - b);
 
-			expect(elapsed1).toBeGreaterThanOrEqual(min - offset);
+			expect(elapsed1).toBeGreaterThanOrEqual(min - offsetLow);
 			expect(elapsed1).toBeLessThanOrEqual(min + offset);
-			expect(elapsed2).toBeGreaterThanOrEqual(med - offset);
+			expect(elapsed2).toBeGreaterThanOrEqual(med - offsetLow);
 			expect(elapsed2).toBeLessThanOrEqual(med + offset);
-			expect(elapsed3).toBeGreaterThanOrEqual(max - offset);
+			expect(elapsed3).toBeGreaterThanOrEqual(max - offsetLow);
 			expect(elapsed3).toBeLessThanOrEqual(max + offset);
 
 			// The global elapsed time is very close to the slowest timeout
-			expect(elapsed).toBeGreaterThanOrEqual(max - offset);
+			expect(elapsed).toBeGreaterThanOrEqual(max - offsetLow);
 			expect(elapsed).toBeLessThanOrEqual(max + offset);
 
 			mutex.unlock();
@@ -131,7 +132,7 @@ describe("Mutex", () => {
 				await mutex.tryLock(delay * 5);
 			});
 
-			expect(elapsed).toBeGreaterThanOrEqual(delay - offset);
+			expect(elapsed).toBeGreaterThanOrEqual(delay - offsetLow);
 			expect(elapsed).toBeLessThanOrEqual(delay + offset);
 		});
 
@@ -187,8 +188,8 @@ describe("Mutex", () => {
 				expect(mutex.queueLength).toBe(0);
 			});
 
-			expect(elapsed).toBeGreaterThanOrEqual(delay * 2 - offset);
-			expect(elapsed).toBeLessThanOrEqual(delay * 2 + offset);
+			expect(elapsed).toBeGreaterThanOrEqual(delay * 2 - offsetLow);
+			expect(elapsed).toBeLessThanOrEqual((delay + offset) * 2);
 		});
 
 		it("should return the value from the critical section", async () => {
@@ -218,7 +219,7 @@ describe("Mutex", () => {
 			);
 
 			// each `tryLockWith` keep the lock for delay / 2 time
-			expect(elapsed).toBeGreaterThanOrEqual(delay - offset);
+			expect(elapsed).toBeGreaterThanOrEqual(delay - offsetLow);
 			expect(elapsed).toBeLessThanOrEqual(delay + offset);
 		});
 

src/semaphore/semaphore.spec.ts

@@ -6,6 +6,10 @@ import { ConcurrencyExceedTimeoutException } from "../exceptions/concurrency.exc
 import { ConcurrencyInvalidTimeoutException } from "../exceptions/concurrency.invalid-timeout.exception";
 
 describe("Semaphore", () => {
+	const delay = 60;
+	const offsetLow = 5;
+	const offset = 15;
+
 	describe("Constructor", () => {
 		it("should create an instance", () => {
 			for (const permits of [1, 10, 100]) {
@@ -71,9 +75,6 @@ describe("Semaphore", () => {
 	});
 
 	describe("`acquire` usage", () => {
-		const delay = 50;
-		const offset = 5;
-
 		it("should work with a single initial permit", async () => {
 			// semaphore as a mutex
 			const semaphore = new Semaphore();
@@ -98,7 +99,7 @@ describe("Semaphore", () => {
 				await semaphore.acquire();
 			});
 
-			expect(elapsed).toBeGreaterThanOrEqual(delay - offset);
+			expect(elapsed).toBeGreaterThanOrEqual(delay - offsetLow);
 			expect(elapsed).toBeLessThanOrEqual(delay + offset);
 
 			semaphore.release();
@@ -124,7 +125,7 @@ describe("Semaphore", () => {
 				await semaphore.acquire();
 			});
 
-			expect(elapsed).toBeGreaterThanOrEqual(delay - offset);
+			expect(elapsed).toBeGreaterThanOrEqual(delay - offsetLow);
 			expect(elapsed).toBeLessThanOrEqual(delay + offset);
 		});
 
@@ -138,7 +139,7 @@ describe("Semaphore", () => {
 					await semaphore.acquire(permits + permitOffset);
 				});
 
-				expect(elapsed).toBeGreaterThanOrEqual(delay - offset);
+				expect(elapsed).toBeGreaterThanOrEqual(delay - offsetLow);
 				expect(elapsed).toBeLessThanOrEqual(delay + offset);
 			}
 		});
@@ -167,25 +168,22 @@ describe("Semaphore", () => {
 				.map(([elapsed]) => elapsed)
 				.sort((a, b) => a - b);
 
-			expect(elapsed1).toBeGreaterThanOrEqual(min - offset);
+			expect(elapsed1).toBeGreaterThanOrEqual(min - offsetLow);
 			expect(elapsed1).toBeLessThanOrEqual(min + offset);
-			expect(elapsed2).toBeGreaterThanOrEqual(med - offset);
+			expect(elapsed2).toBeGreaterThanOrEqual(med - offsetLow);
 			expect(elapsed2).toBeLessThanOrEqual(med + offset);
-			expect(elapsed3).toBeGreaterThanOrEqual(max - offset);
+			expect(elapsed3).toBeGreaterThanOrEqual(max - offsetLow);
 			expect(elapsed3).toBeLessThanOrEqual(max + offset);
 
 			// The global elapsed time is very close to the slowest timeout
-			expect(elapsed).toBeGreaterThanOrEqual(max - offset);
+			expect(elapsed).toBeGreaterThanOrEqual(max - offsetLow);
 			expect(elapsed).toBeLessThanOrEqual(max + offset);
 
 			expect(elapsed).toBeGreaterThanOrEqual(elapsed3);
 		});
 	});
 
 	describe("`tryAcquire` usage", () => {
-		const delay = 50;
-		const offset = 5;
-
 		it("should work with many initial tryAcquires/releases", async () => {
 			for (const permits of [5, 8, 13]) {
 				const semaphore = new Semaphore(permits);
@@ -196,7 +194,7 @@ describe("Semaphore", () => {
 					await semaphore.tryAcquire(delay * 5, permits + permitOffset);
 				});
 
-				expect(elapsed).toBeGreaterThanOrEqual(delay - offset);
+				expect(elapsed).toBeGreaterThanOrEqual(delay - offsetLow);
 				expect(elapsed).toBeLessThanOrEqual(delay + offset);
 			}
 		});