@planet-matrix/mobius-model 0.5.0 → 0.6.0

package/tests/unit/orchestration/coordination/read-write-lock.spec.ts

@@ -0,0 +1,154 @@
+import { afterEach, expect, test, vi } from "vitest"
+
+import { CoordinationAbortError, CoordinationTimeoutError, ReadWriteLock } from "#Source/orchestration/index.ts"
+
+afterEach(() => {
+  vi.clearAllTimers()
+  vi.useRealTimers()
+  vi.restoreAllMocks()
+})
+
+test("ReadWriteLock tracks reader and writer state across immediate acquisitions", () => {
+  const readWriteLock = new ReadWriteLock()
+
+  expect(readWriteLock.isLocked()).toBe(false)
+  expect(readWriteLock.isReadLocked()).toBe(false)
+  expect(readWriteLock.isWriteLocked()).toBe(false)
+
+  const firstReader = readWriteLock.tryAcquireRead()
+  const secondReader = readWriteLock.tryAcquireRead()
+
+  expect(firstReader?.details).toEqual({ coordination: "read-write-lock", mode: "read" })
+  expect(secondReader?.details).toEqual({ coordination: "read-write-lock", mode: "read" })
+  expect(readWriteLock.getActiveReaderCount()).toBe(2)
+  expect(readWriteLock.isReadLocked()).toBe(true)
+  expect(readWriteLock.tryAcquireWrite()).toBeUndefined()
+
+  firstReader?.release()
+  secondReader?.release()
+
+  const writer = readWriteLock.tryAcquireWrite()
+
+  expect(writer?.details).toEqual({ coordination: "read-write-lock", mode: "write" })
+  expect(readWriteLock.isWriteLocked()).toBe(true)
+  expect(readWriteLock.isLocked()).toBe(true)
+
+  writer?.release()
+
+  expect(readWriteLock.isLocked()).toBe(false)
+})
+
+test("ReadWriteLock keeps queued writers ahead of later readers", async () => {
+  const readWriteLock = new ReadWriteLock()
+  const activeReader = readWriteLock.tryAcquireRead()
+
+  expect(activeReader).toBeDefined()
+
+  const writerPromise = readWriteLock.acquireWrite()
+  const lateReaderPromise = readWriteLock.acquireRead()
+
+  expect(readWriteLock.getPendingWriterCount()).toBe(1)
+  expect(readWriteLock.getPendingReaderCount()).toBe(1)
+  expect(readWriteLock.getPendingCount()).toBe(2)
+
+  activeReader?.release()
+
+  const writer = await writerPromise
+  let lateReaderResolved = false
+  void lateReaderPromise.then(() => {
+    lateReaderResolved = true
+  })
+
+  await Promise.resolve()
+
+  expect(readWriteLock.isWriteLocked()).toBe(true)
+  expect(lateReaderResolved).toBe(false)
+
+  writer.release()
+
+  const lateReader = await lateReaderPromise
+
+  expect(readWriteLock.getPendingCount()).toBe(0)
+  expect(readWriteLock.getActiveReaderCount()).toBe(1)
+
+  lateReader.release()
+
+  expect(readWriteLock.isLocked()).toBe(false)
+})
+
+test("ReadWriteLock acquire methods reject on timeout and abort without leaking counts", async () => {
+  vi.useFakeTimers()
+
+  const readWriteLock = new ReadWriteLock()
+  const writer = readWriteLock.tryAcquireWrite()
+
+  expect(writer).toBeDefined()
+
+  const timeoutPromise = readWriteLock.acquireRead({ timeout: 20 })
+
+  expect(readWriteLock.getPendingReaderCount()).toBe(1)
+
+  await vi.advanceTimersByTimeAsync(20)
+
+  await expect(timeoutPromise).rejects.toBeInstanceOf(CoordinationTimeoutError)
+  expect(readWriteLock.getPendingReaderCount()).toBe(0)
+
+  const abortController = new AbortController()
+  const abortPromise = readWriteLock.acquireWrite({ abortSignal: abortController.signal })
+
+  expect(readWriteLock.getPendingWriterCount()).toBe(1)
+
+  abortController.abort("cancelled")
+
+  await expect(abortPromise).rejects.toBeInstanceOf(CoordinationAbortError)
+  expect(readWriteLock.getPendingWriterCount()).toBe(0)
+
+  writer?.release()
+})
+
+test("ReadWriteLock runExclusive methods release permits after callback completion", async () => {
+  const readWriteLock = new ReadWriteLock()
+
+  await expect(readWriteLock.runExclusiveRead(() => "read")).resolves.toBe("read")
+  expect(readWriteLock.isLocked()).toBe(false)
+
+  const error = new Error("write failed")
+
+  await expect(readWriteLock.runExclusiveWrite(() => {
+    throw error
+  })).rejects.toThrow(error)
+
+  expect(readWriteLock.isLocked()).toBe(false)
+})
+
+test("ReadWriteLock duplicate release stays silent by default and uses custom handler when provided", () => {
+  const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {
+    // no-op to silence warnings during test
+  })
+  const silentReadWriteLock = new ReadWriteLock()
+  const silentPermit = silentReadWriteLock.tryAcquireWrite()
+
+  expect(silentPermit).toBeDefined()
+
+  silentPermit?.release()
+  silentPermit?.release()
+  silentPermit?.release()
+
+  expect(silentReadWriteLock.isLocked()).toBe(false)
+  expect(warnSpy).not.toHaveBeenCalled()
+
+  const onDuplicateRelease = vi.fn()
+  const customReadWriteLock = new ReadWriteLock({ onDuplicateRelease })
+  const customPermit = customReadWriteLock.tryAcquireRead()
+
+  expect(customPermit).toBeDefined()
+
+  customPermit?.release()
+  customPermit?.release()
+  customPermit?.release()
+
+  expect(customReadWriteLock.isLocked()).toBe(false)
+  expect(onDuplicateRelease).toHaveBeenCalledTimes(2)
+  expect(onDuplicateRelease).toHaveBeenCalledWith("ReadWriteLock permit release was called more than once.")
+  expect(warnSpy).not.toHaveBeenCalled()
+})

package/tests/unit/orchestration/coordination/semaphore.spec.ts

@@ -0,0 +1,135 @@
+import { afterEach, expect, test, vi } from "vitest"
+
+import { CoordinationAbortError, CoordinationTimeoutError, Semaphore } from "#Source/orchestration/index.ts"
+
+afterEach(() => {
+  vi.clearAllTimers()
+  vi.useRealTimers()
+  vi.restoreAllMocks()
+})
+
+test("Semaphore tracks capacity and grants permits in FIFO order", async () => {
+  const semaphore = new Semaphore(2)
+
+  expect(semaphore.getMaxConcurrency()).toBe(2)
+  expect(semaphore.getActiveCount()).toBe(0)
+  expect(semaphore.getAvailableCount()).toBe(2)
+  expect(semaphore.isSaturated()).toBe(false)
+
+  const firstPermit = semaphore.tryAcquire()
+  const secondPermit = semaphore.tryAcquire()
+
+  expect(firstPermit).toBeDefined()
+  expect(secondPermit).toBeDefined()
+  expect(semaphore.isSaturated()).toBe(true)
+  expect(semaphore.getActiveCount()).toBe(2)
+  expect(semaphore.getAvailableCount()).toBe(0)
+
+  const thirdPermitPromise = semaphore.acquire()
+  const fourthPermitPromise = semaphore.acquire()
+
+  expect(semaphore.getPendingCount()).toBe(2)
+  expect(semaphore.tryAcquire()).toBeUndefined()
+
+  firstPermit?.release()
+
+  const thirdPermit = await thirdPermitPromise
+  let fourthResolved = false
+  void fourthPermitPromise.then(() => {
+    fourthResolved = true
+  })
+
+  await Promise.resolve()
+
+  expect(semaphore.getPendingCount()).toBe(1)
+  expect(fourthResolved).toBe(false)
+
+  secondPermit?.release()
+  const fourthPermit = await fourthPermitPromise
+
+  expect(semaphore.getPendingCount()).toBe(0)
+
+  thirdPermit.release()
+  fourthPermit.release()
+
+  expect(semaphore.getActiveCount()).toBe(0)
+  expect(semaphore.getAvailableCount()).toBe(2)
+  expect(semaphore.isSaturated()).toBe(false)
+})
+
+test("Semaphore acquire rejects on timeout and abort without leaking queue entries", async () => {
+  vi.useFakeTimers()
+
+  const semaphore = new Semaphore(1)
+  const blockingPermit = semaphore.tryAcquire()
+
+  expect(blockingPermit).toBeDefined()
+
+  const timeoutPromise = semaphore.acquire({ timeout: 15 })
+
+  expect(semaphore.getPendingCount()).toBe(1)
+
+  await vi.advanceTimersByTimeAsync(15)
+
+  await expect(timeoutPromise).rejects.toBeInstanceOf(CoordinationTimeoutError)
+  expect(semaphore.getPendingCount()).toBe(0)
+
+  const abortController = new AbortController()
+  const abortPromise = semaphore.acquire({ abortSignal: abortController.signal })
+
+  expect(semaphore.getPendingCount()).toBe(1)
+
+  abortController.abort("stopped")
+
+  await expect(abortPromise).rejects.toBeInstanceOf(CoordinationAbortError)
+  expect(semaphore.getPendingCount()).toBe(0)
+
+  blockingPermit?.release()
+})
+
+test("Semaphore runExclusive releases capacity after callback failure", async () => {
+  const semaphore = new Semaphore(1)
+  const error = new Error("boom")
+
+  await expect(semaphore.runExclusive(() => 1)).resolves.toBe(1)
+  expect(semaphore.getActiveCount()).toBe(0)
+
+  await expect(semaphore.runExclusive(() => {
+    throw error
+  })).rejects.toThrow(error)
+
+  expect(semaphore.getActiveCount()).toBe(0)
+  expect(semaphore.isSaturated()).toBe(false)
+})
+
+test("Semaphore duplicate release stays silent by default and uses custom handler when provided", () => {
+  const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {
+    // no-op to silence warnings during test
+  })
+  const silentSemaphore = new Semaphore(1)
+  const silentPermit = silentSemaphore.tryAcquire()
+
+  expect(silentPermit).toBeDefined()
+
+  silentPermit?.release()
+  silentPermit?.release()
+  silentPermit?.release()
+
+  expect(silentSemaphore.getActiveCount()).toBe(0)
+  expect(warnSpy).not.toHaveBeenCalled()
+
+  const onDuplicateRelease = vi.fn()
+  const customSemaphore = new Semaphore(1, { onDuplicateRelease })
+  const customPermit = customSemaphore.tryAcquire()
+
+  expect(customPermit).toBeDefined()
+
+  customPermit?.release()
+  customPermit?.release()
+  customPermit?.release()
+
+  expect(customSemaphore.getActiveCount()).toBe(0)
+  expect(onDuplicateRelease).toHaveBeenCalledTimes(2)
+  expect(onDuplicateRelease).toHaveBeenCalledWith("Semaphore permit release was called more than once.")
+  expect(warnSpy).not.toHaveBeenCalled()
+})

package/tests/unit/random/string.spec.ts

@@ -0,0 +1,11 @@
+import { expect, test } from "vitest"
+
+import { randomString } from "#Source/random/index.ts"
+
+test("randomString returns expected output", () => {
+  const value = randomString(12)
+  expect(value).toHaveLength(12)
+
+  const constrained = randomString(10, "ab")
+  expect(constrained.split("").every(char => char === "a" || char === "b")).toBe(true)
+})

package/tests/unit/reactor/alien-signals-effect.spec.ts

@@ -49,16 +49,17 @@ test('should not run untracked inner effect', () => {
   let outerEffectTruthyBranchRunTimes = 0;
   const a = signal(() => 3);
   const b = computed(() => a.get() > 0);
-  const _outerEffect = effect(() => {
+  // outer effect
+  effect(() => {
     if (b.get() === true) {
       outerEffectTruthyBranchRunTimes = outerEffectTruthyBranchRunTimes + 1;
-      const _innerEffect = effect(() => {
+      effect(() => {
         if (a.get() === 0) {
           throw new Error("bad");
         }
-      });
+      }, { name: "inner effect" });
     }
-  });
+  }, { name: "outer effect" });
 
   expect(outerEffectTruthyBranchRunTimes).toBe(1);
   a.set(2);
@@ -226,7 +227,7 @@ test('should duplicate subscribers do not affect the notify order', () => {
   const srcB = signal(() => 0, { name: "srcB" });
   const order: string[] = [];
 
-  const _effectA = effect(() => {
+  effect(() => {
     order.push('a');
     reactiveSystem.setNoActiveNodeAsSub();
     const isOne = srcB.get() === 1;
@@ -237,7 +238,7 @@ test('should duplicate subscribers do not affect the notify order', () => {
     srcB.get();
     srcA.get();
   }, { name: "effect-a" });
-  const _effectB = effect(() => {
+  effect(() => {
     order.push('b');
     srcA.get();
   }, { name: "effect-b" });
@@ -357,20 +358,20 @@ test('should not execute skipped effects from previous failed flush when updatin
 
   let effect3Executed = false;
 
-  const _effect1 = effect(() => {
+  effect(() => {
     a.get();
   }, { name: "effect1" });
-  const _effect2 = effect(() => {
+  effect(() => {
     if (a.get() === 2) {
       throw new Error('Error in effect 2');
     }
   }, { name: "effect2" });
-  const _effect3 = effect(() => {
+  effect(() => {
     a.get();
     d.get();
     effect3Executed = true;
   }, { name: "effect3" });
-  const _effect4 = effect(() => {
+  effect(() => {
     b.get();
   }, { name: "effect4" });
 

package/tests/unit/reactor/preact-signal.spec.ts

@@ -1,7 +1,6 @@
 import { describe, it, vi, expect } from "vitest";
 
-import type { Effect } from '#Source/index.ts';
-import { Signal, computed, effect, effectScope, endBatch, reactiveSystem, signal, startBatch } from '#Source/reactor/index.ts';
+import { Signal, effect, signal } from "#Source/reactor/index.ts"
 
 /**
  * 这个测试文件应该与 https://github.com/preactjs/signals/blob/main/packages/core/test/signal.test.tsx 保持同步。

package/tests/unit/singleton/singleton.spec.ts

@@ -0,0 +1,49 @@
+import { expect, test } from "vitest"
+
+import type { SingletonItem } from "#Source/singleton/index.ts"
+import {
+  getSingletonFactory,
+  singletonCollection,
+  singletonItem,
+} from "#Source/singleton/index.ts"
+
+test("getSingletonFactory caches first produced value", () => {
+  let makeCalls = 0
+  const createSingleton = getSingletonFactory(() => {
+    makeCalls = makeCalls + 1
+    return { value: "singleton" }
+  })
+
+  const first = createSingleton()
+  const second = createSingleton()
+
+  expect(first).toBe(second)
+  expect(first.value).toBe("singleton")
+  expect(makeCalls).toBe(1)
+})
+
+test("singletonItem creates named lazy singleton item", () => {
+  let valueCalls = 0
+  const item = singletonItem("config", () => {
+    valueCalls = valueCalls + 1
+    return { enabled: true }
+  })
+
+  const first = item.getValue()
+  const second = item.getValue()
+
+  expect(item.getName()).toBe("config")
+  expect(first).toBe(second)
+  expect(first.enabled).toBe(true)
+  expect(valueCalls).toBe(1)
+})
+
+test("singletonCollection resolves named items and throws for missing names", () => {
+  const portItem: SingletonItem<string, number> = singletonItem("port", () => 3_000)
+  const modeItem: SingletonItem<string, string> = singletonItem("mode", () => "test")
+  const collection = singletonCollection([portItem, modeItem])
+
+  expect(collection.getItem("port")).toBe(3_000)
+  expect(collection.getItem("mode")).toBe("test")
+  expect(() => collection.getItem("missing")).toThrow("GlobalService: item missing not found")
+})