@nocobase/app-template-default 1.0.0-beta.85 → 1.0.0-beta.87

package/tests/server/concurrency.test.ts

@@ -1,4 +1,5 @@
-import { expect, it } from 'vitest';
+import { expect, it, vi } from 'vitest';
+import { ConcurrentAbortError } from '@nocobase/concurrency';
 import { createAppTest } from '@nocobase/app-testing/server';
 import {
   concurrencyServiceToken,
@@ -23,6 +24,55 @@ const test = createAppTest({
   },
 });
 
+test('explicit ttl keeps local Lock and Executor mutually exclusive until actual release', async ({
+  app,
+}) => {
+  const manager = await app.container
+    .resolve(concurrencyServiceToken)
+    .getManager();
+  const lock = await manager.createLock('concurrency-test:ttl', { ttl: 1 });
+  const executor = await manager.createSynchronous('concurrency-test:ttl', {
+    ttl: 2,
+  });
+  vi.useFakeTimers();
+  try {
+    const held = await lock.lock();
+    let entered = false;
+    const done = Promise.withResolvers<string>();
+    const running = executor.run(() => {
+      entered = true;
+      return done.promise;
+    });
+    try {
+      await vi.advanceTimersByTimeAsync(1000);
+      expect(entered).toBe(false);
+      await held.release();
+      await vi.advanceTimersByTimeAsync(0);
+      expect(entered).toBe(true);
+      let successorEntered = false;
+      const next = lock.lock().then((lease) => {
+        successorEntered = true;
+        return lease;
+      });
+      await vi.advanceTimersByTimeAsync(1000);
+      expect(successorEntered).toBe(false);
+      done.resolve('actual');
+      expect(await running).toBe('actual');
+      const successor = await next;
+      await held.release();
+      const attempt = executor.tryRun(() => 'wrong', 10);
+      await vi.advanceTimersByTimeAsync(10);
+      expect(await attempt).toEqual({ acquired: false });
+      await successor.release();
+    } finally {
+      done.resolve('actual');
+      await running;
+      await held.release();
+    }
+  } finally {
+    vi.useRealTimers();
+  }
+});
 test('the real default composition supplies one memory lock domain to two business consumers', async ({
   app,
 }) => {
@@ -50,6 +100,20 @@ test('the real default composition supplies one memory lock domain to two busine
     acquired: true,
     value: 'done',
   });
+  const cancellation = new AbortController();
+  const held = await lock.lock();
+  const cancelled = lock
+    .lock({ signal: cancellation.signal })
+    .catch((error: unknown) => error);
+  cancellation.abort();
+  expect(await cancelled).toBeInstanceOf(ConcurrentAbortError);
+  await held.release();
+  const active = await lock.lock();
+  const interrupted = lock.lock().catch((error: unknown) => error);
+  await app.shutdown();
+  expect(await interrupted).toBeInstanceOf(ConcurrentAbortError);
+  await active.release();
+  await expect(lock.lock()).rejects.toBeInstanceOf(ConcurrentAbortError);
 });
 
 it('declares only the default selector environment variable and no public configuration', () => {