cabloy 5.1.112 → 5.1.114

package/vona/src/suite/a-commerce/modules/commerce-trade/test/stockBalance.test.ts

@@ -2,11 +2,24 @@ import type { DtoStockAdjust, EntityStockBalance } from 'vona-module-commerce-tr
 
 import { catchError } from '@cabloy/utils';
 import assert from 'node:assert';
+import { randomUUID } from 'node:crypto';
 import { describe, it } from 'node:test';
 import { app } from 'vona-mock';
 
 const actionPath = '/commerce/trade/stockBalance/adjustStock';
 
+interface IStockFixture {
+  categoryId: number;
+  productId: number;
+  skuId: number;
+}
+
+type IStockFixturePartial = Partial<IStockFixture>;
+
+function createTestId() {
+  return randomUUID().slice(0, 12);
+}
+
 function stockAdjust(skuId: number, delta: number, suffix: string): DtoStockAdjust {
   return {
     skuId,
@@ -16,57 +29,101 @@ function stockAdjust(skuId: number, delta: number, suffix: string): DtoStockAdju
   };
 }
 
-async function createSku(suffix: string): Promise<number> {
-  const categoryId = await app.bean.executor.performAction('post', '/commerce/catalog/category', {
-    body: { name: `stock-category-${suffix}`, published: true },
-  });
-  const productId = await app.bean.executor.performAction('post', '/commerce/catalog/product', {
-    body: { categoryId, title: `stock-product-${suffix}`, published: true },
-  });
-  return await app.bean.executor.performAction('post', '/commerce/catalog/sku', {
-    body: {
-      productId,
-      code: `stock-sku-${suffix}`,
-      priceCents: 100,
-      lifecycle: 'active',
-    },
-  });
+async function createSku(suffix: string): Promise<IStockFixture> {
+  const fixture: IStockFixturePartial = {};
+  try {
+    fixture.categoryId = await app.bean.executor.performAction(
+      'post',
+      '/commerce/catalog/category',
+      {
+        body: { name: `stock-category-${suffix}`, published: true },
+      },
+    );
+    fixture.productId = await app.bean.executor.performAction('post', '/commerce/catalog/product', {
+      body: { categoryId: fixture.categoryId, title: `stock-product-${suffix}`, published: true },
+    });
+    fixture.skuId = await app.bean.executor.performAction('post', '/commerce/catalog/sku', {
+      body: {
+        productId: fixture.productId,
+        code: `stock-sku-${suffix}`,
+        priceCents: 100,
+        lifecycle: 'active',
+      },
+    });
+    return fixture as IStockFixture;
+  } catch (error) {
+    await dropStockFixture(fixture);
+    throw error;
+  }
+}
+
+async function dropStockFixture(fixture: IStockFixturePartial | undefined) {
+  if (!fixture) return;
+  const scopeTrade = app.scope('commerce-trade');
+  const scopeCatalog = app.scope('commerce-catalog');
+  if (fixture.skuId !== undefined) {
+    await scopeTrade.model.stockAudit.delete({ skuId: fixture.skuId });
+    await scopeTrade.model.stockReservation.delete({ skuId: fixture.skuId });
+    await scopeTrade.model.stockBalance.delete({ skuId: fixture.skuId });
+    await scopeCatalog.model.sku.delete({ id: fixture.skuId });
+  }
+  if (fixture.productId !== undefined) {
+    await scopeCatalog.model.product.delete({ id: fixture.productId });
+  }
+  if (fixture.categoryId !== undefined) {
+    await scopeCatalog.model.category.delete({ id: fixture.categoryId });
+  }
 }
 
 async function adjustStock(stockAdjust: DtoStockAdjust): Promise<EntityStockBalance> {
   return await app.bean.executor.performAction('post', actionPath, { body: stockAdjust });
 }
 
-describe('stockBalance.test.ts', () => {
+describe('stockBalance.test.ts', { concurrency: false }, () => {
   it('action:stockBalance:adjustStock appends an audit with server-scoped balance', async () => {
     await app.bean.executor.mockCtx(async () => {
+      let fixture: IStockFixture | undefined;
       await app.bean.passport.signinMock();
       try {
-        const skuId = await createSku(`${Date.now()}`);
-        const balance = await adjustStock(stockAdjust(skuId, 8, `${skuId}-initial`));
+        fixture = await createSku(createTestId());
+        const balance = await adjustStock(
+          stockAdjust(fixture.skuId, 8, `${fixture.skuId}-initial`),
+        );
         assert.equal(balance.onHand, 8);
         assert.equal(balance.reserved, 0);
         assert.equal(balance.available, 8);
 
-        const adjusted = await adjustStock(stockAdjust(skuId, -3, `${skuId}-decrement`));
+        const adjusted = await adjustStock(
+          stockAdjust(fixture.skuId, -3, `${fixture.skuId}-decrement`),
+        );
         assert.equal(adjusted.id, balance.id);
         assert.equal(adjusted.onHand, 5);
         assert.equal(adjusted.reserved, 0);
         assert.equal(adjusted.available, 5);
 
         const audits = await app.scope('commerce-trade').model.stockAudit.select({
-          where: { skuId },
+          where: { skuId: fixture.skuId },
         });
         assert.equal(audits.length, 2);
         assert.deepEqual(
-          audits.map(item => [item.delta, item.onHand, item.reserved, item.available]),
+          audits.map(item => [
+            item.delta,
+            item.priorOnHand,
+            item.priorReserved,
+            item.priorAvailable,
+            item.onHand,
+            item.reserved,
+            item.available,
+          ]),
           [
-            [8, 8, 0, 8],
-            [-3, 5, 0, 5],
+            [8, 0, 0, 0, 8, 0, 8],
+            [-3, 8, 0, 8, 5, 0, 5],
           ],
         );
+        assert.equal(String(audits[0].actorId), String(app.bean.passport.currentUser!.id));
         assert.equal(audits[1].stockBalanceId, balance.id);
       } finally {
+        await dropStockFixture(fixture);
         await app.bean.passport.signout();
       }
     });
@@ -74,12 +131,15 @@ describe('stockBalance.test.ts', () => {
 
   it('action:stockBalance:adjustStock rejects negative stock without an audit', async () => {
     await app.bean.executor.mockCtx(async () => {
+      let fixture: IStockFixture | undefined;
       await app.bean.passport.signinMock();
       try {
-        const skuId = await createSku(`${Date.now()}`);
-        const balance = await adjustStock(stockAdjust(skuId, 2, `${skuId}-initial`));
+        fixture = await createSku(createTestId());
+        const balance = await adjustStock(
+          stockAdjust(fixture.skuId, 2, `${fixture.skuId}-initial`),
+        );
         const [_, err] = await catchError(() =>
-          adjustStock(stockAdjust(skuId, -3, `${skuId}-reject`)),
+          adjustStock(stockAdjust(fixture.skuId, -3, `${fixture.skuId}-reject`)),
         );
         assert.match(err?.message ?? '', /negative/);
 
@@ -87,39 +147,66 @@ describe('stockBalance.test.ts', () => {
         assert.equal(unchanged?.onHand, 2);
         assert.equal(unchanged?.available, 2);
         const audits = await app.scope('commerce-trade').model.stockAudit.select({
-          where: { skuId },
+          where: { skuId: fixture.skuId },
         });
         assert.equal(audits.length, 1);
       } finally {
+        await dropStockFixture(fixture);
         await app.bean.passport.signout();
       }
     });
   });
 
-  it('action:stockBalance:adjustStock rolls back the balance when audit insertion fails', async () => {
+  it('rolls back balance and audit writes in one transaction', async () => {
     await app.bean.executor.mockCtx(async () => {
+      let fixture: IStockFixture | undefined;
       await app.bean.passport.signinMock();
       try {
-        const skuId = await createSku(`${Date.now()}`);
-        const balance = await adjustStock(stockAdjust(skuId, 4, `${skuId}-initial`));
-        const modelStockAudit = app.scope('commerce-trade').model.stockAudit;
-        const insert = modelStockAudit.insert.bind(modelStockAudit);
-        (modelStockAudit as any).insert = async () => {
-          throw new Error('audit insert failure');
-        };
-        try {
-          const [_, err] = await catchError(() =>
-            adjustStock(stockAdjust(skuId, 1, `${skuId}-rollback`)),
-          );
-          assert.match(err?.message ?? '', /audit insert failure/);
-        } finally {
-          (modelStockAudit as any).insert = insert;
-        }
+        fixture = await createSku(createTestId());
+        const balance = await adjustStock(
+          stockAdjust(fixture.skuId, 4, `${fixture.skuId}-initial`),
+        );
+        const db = app.ctx.db;
+        const [_, err] = await catchError(async () => {
+          await db.transaction.begin(async () => {
+            const modelStockBalance = app
+              .scope('commerce-trade')
+              .model.stockBalance.newInstance(db);
+            const modelStockAudit = app.scope('commerce-trade').model.stockAudit.newInstance(db);
+            await modelStockBalance.updateById(balance.id, {
+              onHand: 5,
+              reserved: 0,
+              available: 5,
+            });
+            await modelStockAudit.insert({
+              stockBalanceId: balance.id,
+              skuId: fixture!.skuId,
+              actorId: app.bean.passport.currentUser!.id,
+              operation: 'adjust',
+              delta: 1,
+              reason: 'transaction rollback proof',
+              correlationId: `stock-test-${fixture!.skuId}-rollback`,
+              priorOnHand: 4,
+              priorReserved: 0,
+              priorAvailable: 4,
+              onHand: 5,
+              reserved: 0,
+              available: 5,
+            });
+            throw new Error('transaction rollback proof');
+          });
+        });
+        assert.match(err?.message ?? '', /transaction rollback proof/);
 
         const unchanged = await app.scope('commerce-trade').model.stockBalance.getById(balance.id);
         assert.equal(unchanged?.onHand, 4);
         assert.equal(unchanged?.available, 4);
+        const audits = await app.scope('commerce-trade').model.stockAudit.select({
+          where: { skuId: fixture.skuId },
+        });
+        assert.equal(audits.length, 1);
       } finally {
+        await dropStockFixture(fixture);
         await app.bean.passport.signout();
       }
     });
@@ -149,38 +236,159 @@ describe('stockBalance.test.ts', () => {
   });
 
   it('action:stockBalance:adjustStock treats a cross-instance SKU as not found', async () => {
-    let skuId!: number;
-    await app.bean.executor.mockCtx(async () => {
-      await app.bean.passport.signinMock();
-      try {
-        skuId = await createSku(`${Date.now()}`);
-        await adjustStock(stockAdjust(skuId, 5, `${skuId}-default`));
-      } finally {
-        await app.bean.passport.signout();
-      }
-    });
+    let fixture: IStockFixture | undefined;
+    try {
+      await app.bean.executor.mockCtx(async () => {
+        await app.bean.passport.signinMock();
+        try {
+          fixture = await createSku(createTestId());
+          await adjustStock(stockAdjust(fixture.skuId, 5, `${fixture.skuId}-default`));
+        } finally {
+          await app.bean.passport.signout();
+        }
+      });
 
-    await app.bean.executor.mockCtx(
-      async () => {
+      await app.bean.executor.mockCtx(
+        async () => {
+          await app.bean.passport.signinMock();
+          try {
+            const [_, err] = await catchError(() =>
+              adjustStock(stockAdjust(fixture!.skuId, 1, `${fixture!.skuId}-share`)),
+            );
+            assert.equal(err?.code, 404);
+            assert.equal(
+              await app.scope('commerce-trade').model.stockBalance.get({ skuId: fixture!.skuId }),
+              undefined,
+            );
+            assert.deepEqual(
+              await app.scope('commerce-trade').model.stockAudit.select({
+                where: { skuId: fixture!.skuId },
+              }),
+              [],
+            );
+          } finally {
+            await app.bean.passport.signout();
+          }
+        },
+        { instanceName: 'shareTest' as any },
+      );
+    } finally {
+      await app.bean.executor.mockCtx(async () => {
+        await dropStockFixture(fixture);
+      });
+    }
+  });
+
+  it('hides foreign stock balances and audits from operator read APIs', async () => {
+    const suffix = createTestId();
+    let fixture: IStockFixture | undefined;
+    let balanceId!: number;
+    let auditId!: number;
+    const reason = `stock read isolation ${suffix}`;
+    const correlationId = `stock-read-isolation-${suffix}`;
+    try {
+      await app.bean.executor.mockCtx(async () => {
         await app.bean.passport.signinMock();
         try {
-          const [_, err] = await catchError(() =>
-            adjustStock(stockAdjust(skuId, 1, `${skuId}-share`)),
+          fixture = await createSku(suffix);
+          const balance = await adjustStock({
+            skuId: fixture.skuId,
+            delta: 5,
+            reason,
+            correlationId,
+          });
+          balanceId = balance.id;
+          const audits = await app.scope('commerce-trade').model.stockAudit.select({
+            where: { skuId: fixture.skuId },
+          });
+          assert.equal(audits.length, 1);
+          auditId = audits[0].id;
+        } finally {
+          await app.bean.passport.signout();
+        }
+      });
+
+      await app.bean.executor.mockCtx(
+        async () => {
+          await app.bean.passport.signinMock();
+          try {
+            assert.equal(
+              await app.bean.executor.performAction('get', '/commerce/trade/stockBalance/:id', {
+                params: { id: balanceId },
+              }),
+              undefined,
+            );
+            const balances = await app.bean.executor.performAction(
+              'get',
+              '/commerce/trade/stockBalance',
+            );
+            assert.equal(
+              balances.list.some(
+                (balance: { id: unknown }) => String(balance.id) === String(balanceId),
+              ),
+              false,
+            );
+            assert.equal(
+              await app.bean.executor.performAction('get', '/commerce/trade/stockAudit/:id', {
+                params: { id: auditId },
+              }),
+              undefined,
+            );
+            const audits = await app.bean.executor.performAction(
+              'get',
+              '/commerce/trade/stockAudit',
+            );
+            assert.equal(
+              audits.list.some((audit: { id: unknown }) => String(audit.id) === String(auditId)),
+              false,
+            );
+          } finally {
+            await app.bean.passport.signout();
+          }
+        },
+        { instanceName: 'shareTest' as any },
+      );
+
+      await app.bean.executor.mockCtx(async () => {
+        await app.bean.passport.signinMock();
+        try {
+          const balance = await app.bean.executor.performAction(
+            'get',
+            '/commerce/trade/stockBalance/:id',
+            { params: { id: balanceId } },
+          );
+          assert.deepEqual(
+            [balance.id, balance.skuId, balance.onHand, balance.reserved, balance.available],
+            [balanceId, fixture!.skuId, 5, 0, 5],
           );
-          assert.equal(err?.code, 404);
-          assert.equal(
-            await app.scope('commerce-trade').model.stockBalance.get({ skuId }),
-            undefined,
+          const audit = await app.bean.executor.performAction(
+            'get',
+            '/commerce/trade/stockAudit/:id',
+            { params: { id: auditId } },
           );
           assert.deepEqual(
-            await app.scope('commerce-trade').model.stockAudit.select({ where: { skuId } }),
-            [],
+            [
+              audit.id,
+              audit.stockBalanceId,
+              audit.skuId,
+              audit.operation,
+              audit.delta,
+              audit.reason,
+              audit.correlationId,
+              audit.onHand,
+              audit.reserved,
+              audit.available,
+            ],
+            [auditId, balanceId, fixture!.skuId, 'adjust', 5, reason, correlationId, 5, 0, 5],
           );
         } finally {
           await app.bean.passport.signout();
         }
-      },
-      { instanceName: 'shareTest' as any },
-    );
+      });
+    } finally {
+      await app.bean.executor.mockCtx(async () => {
+        await dropStockFixture(fixture);
+      });
+    }
   });
 });