framework/concurrent/Semaphore.test.ts

import Condition from "@framework/concurrent/Condition";
import Semaphore from "@framework/concurrent/Semaphore";
import { setTimeout } from "timers/promises";
import { describe, expect, it, vi } 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]);
            }
        );
    });

    it("works with a condition", async () => {
        const condition = new Condition();

        condition.wait = vi.fn();
        condition.signal = vi.fn();

        // Arrange
        const semaphore = new Semaphore({
            maxPermits: 1,
            condition
        });

        // Act
        await semaphore.acquire();

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