framework/concurrent/Mutex.test.ts

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

describe("Mutex", () => {
    describe("basic usage", () => {
        it("should lock and unlock", async () => {
            // Arrange
            const mutex = new Mutex();

            // Act
            await mutex.lock();
            mutex.unlock();

            // Assert
            expect(mutex.isUnlocked()).toBe(true);
        });

        it("should lock and unlock with extraneous releases", async () => {
            // Arrange
            const mutex = new Mutex({ ignoreExtraneousUnlocks: true });

            // Act
            await mutex.lock();
            mutex.unlock();

            // Assert
            expect(mutex.isUnlocked()).toBe(true);
        });

        it("should lock and unlock with extraneous releases and ignore them", async () => {
            // Arrange
            const mutex = new Mutex({ ignoreExtraneousUnlocks: true });

            // Act
            await mutex.lock();
            mutex.unlock();
            mutex.unlock();

            // Assert
            expect(mutex.isUnlocked()).toBe(true);
        });

        it("should lock and unlock with extraneous releases and throw an error if opted-in", async () => {
            // Arrange
            const mutex = new Mutex({
                ignoreExtraneousUnlocks: false
            });

            // Act
            await mutex.lock();
            mutex.unlock();

            // Assert
            expect(() => mutex.unlock()).toThrowError("This mutex is not locked yet.");
        });
    });

    describe("race condition checks", () => {
        it(
            "should lock and unlock with multiple locks",
            {
                repeats: 10
            },
            async () => {
                // Arrange
                const mutex = new Mutex();
                const output: number[] = [];
                const fn1 = async () => {
                    await mutex.lock();
                    await setTimeout(700 * Math.random());
                    output.push(1);
                    mutex.unlock();
                };

                const fn2 = async () => {
                    await mutex.lock();
                    await setTimeout(240 * Math.random());
                    output.push(2);
                    mutex.unlock();
                };

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

                // Assert
                expect(output).toEqual([1, 2]);
            }
        );
    });
});
1	import Mutex from "@framework/concurrent/Mutex";
2	import { setTimeout } from "timers/promises";
3	import { describe, expect, it } from "vitest";
4
5	describe("Mutex", () => {
6	describe("basic usage", () => {
7	it("should lock and unlock", async () => {
8	// Arrange
9	const mutex = new Mutex();
10
11	// Act
12	await mutex.lock();
13	mutex.unlock();
14
15	// Assert
16	expect(mutex.isUnlocked()).toBe(true);
17	});
18
19	it("should lock and unlock with extraneous releases", async () => {
20	// Arrange
21	const mutex = new Mutex({ ignoreExtraneousUnlocks: true });
22
23	// Act
24	await mutex.lock();
25	mutex.unlock();
26
27	// Assert
28	expect(mutex.isUnlocked()).toBe(true);
29	});
30
31	it("should lock and unlock with extraneous releases and ignore them", async () => {
32	// Arrange
33	const mutex = new Mutex({ ignoreExtraneousUnlocks: true });
34
35	// Act
36	await mutex.lock();
37	mutex.unlock();
38	mutex.unlock();
39
40	// Assert
41	expect(mutex.isUnlocked()).toBe(true);
42	});
43
44	it("should lock and unlock with extraneous releases and throw an error if opted-in", async () => {
45	// Arrange
46	const mutex = new Mutex({
47	ignoreExtraneousUnlocks: false
48	});
49
50	// Act
51	await mutex.lock();
52	mutex.unlock();
53
54	// Assert
55	expect(() => mutex.unlock()).toThrowError("This mutex is not locked yet.");
56	});
57	});
58
59	describe("race condition checks", () => {
60	it(
61	"should lock and unlock with multiple locks",
62	{
63	repeats: 10
64	},
65	async () => {
66	// Arrange
67	const mutex = new Mutex();
68	const output: number[] = [];
69	const fn1 = async () => {
70	await mutex.lock();
71	await setTimeout(700 * Math.random());
72	output.push(1);
73	mutex.unlock();
74	};
75
76	const fn2 = async () => {
77	await mutex.lock();
78	await setTimeout(240 * Math.random());
79	output.push(2);
80	mutex.unlock();
81	};
82
83	// Act
84	await Promise.all([fn1(), fn2()]);
85
86	// Assert
87	expect(output).toEqual([1, 2]);
88	}
89	);
90	});
91	});