framework/concurrent/Semaphore.test.ts

import Semaphore from "@framework/concurrent/Semaphore";
import { setTimeout } from "timers/promises";
import { describe, expect, it } from "vitest";

describe("Semaphore", () => {
    describe("basic usage", () => {
        it("can be acquired and released", async () => {
            // Arrange
            const semaphore = new Semaphore(1);

            // Act
            await semaphore.acquire();
            semaphore.release();

            // Assert
            expect(semaphore.availablePermits).toBe(1);
        });

        it("can be acquired and released with extraneous releases", async () => {
            // Arrange
            const semaphore = new Semaphore({
                ignoreExtraneousReleases: true,
                maxPermits: 1
            });

            // Act
            await semaphore.acquire();
            const permitsAfterAcquire = semaphore.availablePermits;
            semaphore.release();

            // Assert
            expect(semaphore.availablePermits).toBe(1);
            expect(permitsAfterAcquire).toBe(0);
        });

        it("can be acquired and released with extraneous releases and ignore them", async () => {
            // Arrange
            const semaphore = new Semaphore({
                ignoreExtraneousReleases: true,
                maxPermits: 1
            });

            // Act
            await semaphore.acquire();
            const permitsAfterAcquire = semaphore.availablePermits;
            semaphore.release();
            const permitsAfterFirstRelease = semaphore.availablePermits;
            semaphore.release();

            // Assert
            expect(semaphore.availablePermits).toBe(1);
            expect(permitsAfterFirstRelease).toBe(1);
            expect(permitsAfterAcquire).toBe(0);
        });

        it("can be acquired with extraneous releases and throws an error if opted-in", async () => {
            // Arrange
            const semaphore = new Semaphore({
                ignoreExtraneousReleases: false,
                maxPermits: 1
            });

            // Act
            await semaphore.acquire();
            semaphore.release();

            // Assert
            expect(() => semaphore.release()).toThrowError(
                Semaphore.EXTRANEOUS_RELEASE_ERROR_MESSAGE
            );
        });
    });

    describe("race condition checks", () => {
        it(
            "can be acquired and released with multiple acquires",
            {
                repeats: 10
            },
            async () => {
                // Arrange
                const semaphore = new Semaphore(1);
                const output: number[] = [];
                const fn1 = async () => {
                    await semaphore.acquire();
                    await setTimeout(700 * Math.random());
                    output.push(1);
                    semaphore.release();
                };

                const fn2 = async () => {
                    await semaphore.acquire();
                    await setTimeout(240 * Math.random());
                    output.push(2);
                    semaphore.release();
                };

                // Act
                await Promise.all([fn1(), fn2(), fn2(), fn1(), fn1()]);

                // Assert
                expect(semaphore.availablePermits).toBe(1);
                expect(output).toStrictEqual([1, 2, 2, 1, 1]);
            }
        );
    });
});
1	rakinar2	577	import Semaphore from "@framework/concurrent/Semaphore";
2			import { setTimeout } from "timers/promises";
3			import { describe, expect, it } from "vitest";
4
5			describe("Semaphore", () => {
6			describe("basic usage", () => {
7			it("can be acquired and released", async () => {
8			// Arrange
9			const semaphore = new Semaphore(1);
10
11			// Act
12			await semaphore.acquire();
13			semaphore.release();
14
15			// Assert
16			expect(semaphore.availablePermits).toBe(1);
17			});
18
19			it("can be acquired and released with extraneous releases", async () => {
20			// Arrange
21			const semaphore = new Semaphore({
22			ignoreExtraneousReleases: true,
23			maxPermits: 1
24			});
25
26			// Act
27			await semaphore.acquire();
28			const permitsAfterAcquire = semaphore.availablePermits;
29			semaphore.release();
30
31			// Assert
32			expect(semaphore.availablePermits).toBe(1);
33			expect(permitsAfterAcquire).toBe(0);
34			});
35
36			it("can be acquired and released with extraneous releases and ignore them", async () => {
37			// Arrange
38			const semaphore = new Semaphore({
39			ignoreExtraneousReleases: true,
40			maxPermits: 1
41			});
42
43			// Act
44			await semaphore.acquire();
45			const permitsAfterAcquire = semaphore.availablePermits;
46			semaphore.release();
47			const permitsAfterFirstRelease = semaphore.availablePermits;
48			semaphore.release();
49
50			// Assert
51			expect(semaphore.availablePermits).toBe(1);
52			expect(permitsAfterFirstRelease).toBe(1);
53			expect(permitsAfterAcquire).toBe(0);
54			});
55
56			it("can be acquired with extraneous releases and throws an error if opted-in", async () => {
57			// Arrange
58			const semaphore = new Semaphore({
59			ignoreExtraneousReleases: false,
60			maxPermits: 1
61			});
62
63			// Act
64			await semaphore.acquire();
65			semaphore.release();
66
67			// Assert
68			expect(() => semaphore.release()).toThrowError(
69			Semaphore.EXTRANEOUS_RELEASE_ERROR_MESSAGE
70			);
71			});
72			});
73
74			describe("race condition checks", () => {
75			it(
76			"can be acquired and released with multiple acquires",
77			{
78			repeats: 10
79			},
80			async () => {
81			// Arrange
82			const semaphore = new Semaphore(1);
83			const output: number[] = [];
84			const fn1 = async () => {
85			await semaphore.acquire();
86			await setTimeout(700 * Math.random());
87			output.push(1);
88			semaphore.release();
89			};
90
91			const fn2 = async () => {
92			await semaphore.acquire();
93			await setTimeout(240 * Math.random());
94			output.push(2);
95			semaphore.release();
96			};
97
98			// Act
99			await Promise.all([fn1(), fn2(), fn2(), fn1(), fn1()]);
100
101			// Assert
102			expect(semaphore.availablePermits).toBe(1);
103			expect(output).toStrictEqual([1, 2, 2, 1, 1]);
104			}
105			);
106			});
107			});