cabloy 5.1.111 → 5.1.112

package/vona/src/suite/a-commerce/modules/commerce-catalog/src/service/product.ts

@@ -0,0 +1,162 @@
+import type { Knex } from 'knex';
+import type { TableIdentity } from 'table-identity';
+import type { IQueryParams } from 'vona-module-a-orm';
+
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+
+import type { DtoProductCreate } from '../dto/productCreate.tsx';
+import type { DtoProductPublic } from '../dto/productPublic.tsx';
+import type { DtoProductPublicSelectRes } from '../dto/productPublicSelectRes.tsx';
+import type { DtoProductSelectRes } from '../dto/productSelectRes.tsx';
+import type { DtoProductUpdate } from '../dto/productUpdate.tsx';
+import type { DtoProductView } from '../dto/productView.tsx';
+import type { EntityProduct } from '../entity/product.tsx';
+import type { ModelProduct } from '../model/product.ts';
+
+@Service()
+export class ServiceProduct extends BeanBase {
+  async create(product: DtoProductCreate): Promise<EntityProduct> {
+    await this._ensureCategoryExists(product.categoryId);
+    return await this.scope.model.product.insert(product);
+  }
+
+  async select(params?: IQueryParams<ModelProduct>): Promise<DtoProductSelectRes> {
+    return await this.scope.model.product.selectAndCount(params);
+  }
+
+  async selectPublic(params: IQueryParams<ModelProduct>): Promise<DtoProductPublicSelectRes> {
+    const result = await this.scope.model.product.selectAndCount({
+      columns: ['id', 'title', 'description', 'categoryId'],
+      where: this._getPublicProductWhere(params.where),
+      orders: [['id', 'asc']],
+      limit: params.limit ?? 20,
+      offset: params.offset ?? 0,
+      include: {
+        category: { columns: ['id', 'name'] },
+        skuAvailables: true,
+      },
+    });
+    const balancesBySkuId = await this._getBalancesBySkuId(
+      result.list.flatMap((product: any) => product.skuAvailables.map((sku: any) => sku.id)),
+    );
+    return {
+      ...result,
+      list: result.list.flatMap((product: any) => {
+        const item = this._toPublicProduct(product, balancesBySkuId);
+        return item ? [item] : [];
+      }),
+    };
+  }
+
+  async view(id: TableIdentity): Promise<DtoProductView | undefined> {
+    return await this.scope.model.product.getById(id);
+  }
+
+  async viewPublic(id: TableIdentity): Promise<DtoProductPublic | undefined> {
+    const product = await this.scope.model.product.get(this._getPublicProductWhere({ id }), {
+      columns: ['id', 'title', 'description', 'categoryId'],
+      include: {
+        category: { columns: ['id', 'name'] },
+        skuAvailables: true,
+      },
+    });
+    if (!product) return undefined;
+    const balancesBySkuId = await this._getBalancesBySkuId(
+      product.skuAvailables.map(sku => sku.id),
+    );
+    return this._toPublicProduct(product, balancesBySkuId);
+  }
+
+  async update(id: TableIdentity, product: DtoProductUpdate) {
+    if (product.categoryId !== undefined) await this._ensureCategoryExists(product.categoryId);
+    return await this.scope.model.product.updateById(id, product);
+  }
+
+  async delete(id: TableIdentity) {
+    return await this.scope.model.product.deleteById(id);
+  }
+
+  private _getPublicProductWhere(where?: Record<string, unknown>) {
+    const productModel = this.scope.model.product;
+    const categoryModel = this.scope.model.category;
+    const skuModel = this.scope.model.sku;
+    const stockBalanceModel = this.$scope.commerceTrade.model.stockBalance;
+    return {
+      ...where,
+      published: true,
+      _exists_: function (this: Knex.QueryBuilder) {
+        this.select(1)
+          .from('commerceCatalogSku')
+          .innerJoin('commerceTradeStockBalance', function () {
+            this.on('commerceCatalogSku.id', '=', 'commerceTradeStockBalance.skuId').andOn(
+              'commerceCatalogSku.iid',
+              '=',
+              'commerceTradeStockBalance.iid',
+            );
+          });
+        skuModel.prepareWhere(this, 'commerceCatalogSku', { lifecycle: 'active' });
+        this.where('commerceCatalogSku.productId', productModel.ref('commerceCatalogProduct.id'));
+        stockBalanceModel.prepareWhere(this, 'commerceTradeStockBalance', {
+          available: { _gt_: 0 },
+        });
+        this.whereExists(function (this: Knex.QueryBuilder) {
+          this.select(1).from('commerceCatalogCategory');
+          categoryModel.prepareWhere(this, 'commerceCatalogCategory', { published: true });
+          this.where(
+            'commerceCatalogCategory.id',
+            productModel.ref('commerceCatalogProduct.categoryId'),
+          );
+        });
+      } as any,
+    };
+  }
+
+  private async _getBalancesBySkuId(skuIds: TableIdentity[]) {
+    if (skuIds.length === 0) return new Map<string, number>();
+    const balances = await this.$scope.commerceTrade.model.stockBalance.select({
+      columns: ['skuId', 'available'],
+      where: {
+        skuId: skuIds,
+        available: { _gt_: 0 },
+      },
+    });
+    return new Map(balances.map(balance => [String(balance.skuId), balance.available]));
+  }
+
+  private _toPublicProduct(
+    product: any,
+    balancesBySkuId: Map<string, number>,
+  ): DtoProductPublic | undefined {
+    if (!product.category) return undefined;
+    const skuAvailables = product.skuAvailables.flatMap((sku: any) => {
+      const available = balancesBySkuId.get(String(sku.id));
+      if (!available) return [];
+      return [
+        {
+          id: sku.id,
+          code: sku.code,
+          priceCents: sku.priceCents,
+          available,
+        },
+      ];
+    });
+    if (skuAvailables.length === 0) return undefined;
+    return {
+      id: product.id,
+      title: product.title,
+      description: product.description,
+      categoryId: product.category.id,
+      categoryName: product.category.name,
+      priceCents: Math.min(...skuAvailables.map((sku: any) => sku.priceCents)),
+      available: skuAvailables.reduce((total: number, sku: any) => total + sku.available, 0),
+      skuAvailables,
+    };
+  }
+
+  private async _ensureCategoryExists(categoryId: TableIdentity) {
+    if (!(await this.scope.model.category.getById(categoryId))) {
+      this.app.throw(404, 'Product category not found');
+    }
+  }
+}

package/vona/src/suite/a-commerce/modules/commerce-catalog/src/service/sku.ts

@@ -0,0 +1,76 @@
+import type { TableIdentity } from 'table-identity';
+import type { IQueryParams } from 'vona-module-a-orm';
+
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+import { Core } from 'vona-module-a-core';
+
+import type { DtoSkuCreate } from '../dto/skuCreate.tsx';
+import type { DtoSkuSelectRes } from '../dto/skuSelectRes.tsx';
+import type { DtoSkuUpdate } from '../dto/skuUpdate.tsx';
+import type { DtoSkuView } from '../dto/skuView.tsx';
+import type { EntitySku } from '../entity/sku.tsx';
+import type { ModelSku } from '../model/sku.ts';
+
+const allowedLifecycleTransitions: Record<EntitySku['lifecycle'], EntitySku['lifecycle'][]> = {
+  draft: ['active', 'archived'],
+  active: ['inactive', 'archived'],
+  inactive: ['active', 'archived'],
+  archived: [],
+};
+
+@Service()
+export class ServiceSku extends BeanBase {
+  async create(sku: DtoSkuCreate): Promise<EntitySku> {
+    await this._ensureProductExists(sku.productId);
+    await this._ensureCodeAvailable(sku.code);
+    return await this.scope.model.sku.insert(sku);
+  }
+
+  async select(params?: IQueryParams<ModelSku>): Promise<DtoSkuSelectRes> {
+    return await this.scope.model.sku.selectAndCount(params);
+  }
+
+  async view(id: TableIdentity): Promise<DtoSkuView | undefined> {
+    return await this.scope.model.sku.getById(id);
+  }
+
+  @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
+  async update(id: TableIdentity, sku: DtoSkuUpdate) {
+    if (sku.lifecycle !== undefined) {
+      const currentSku = await this.scope.model.sku.getByIdForUpdate(id);
+      if (!currentSku) {
+        this.app.throw(404, 'SKU not found');
+      }
+      if (
+        sku.lifecycle !== currentSku.lifecycle &&
+        !allowedLifecycleTransitions[currentSku.lifecycle].includes(sku.lifecycle)
+      ) {
+        this.app.throw(
+          409,
+          `cannot transition SKU lifecycle from ${currentSku.lifecycle} to ${sku.lifecycle}`,
+        );
+      }
+    }
+    if (sku.productId !== undefined) await this._ensureProductExists(sku.productId);
+    if (sku.code) await this._ensureCodeAvailable(sku.code, id);
+    return await this.scope.model.sku.updateById(id, sku);
+  }
+
+  async delete(id: TableIdentity) {
+    return await this.scope.model.sku.deleteById(id);
+  }
+
+  private async _ensureProductExists(productId: TableIdentity) {
+    if (!(await this.scope.model.product.getById(productId))) {
+      this.app.throw(404, 'SKU product not found');
+    }
+  }
+
+  private async _ensureCodeAvailable(code: string, excludedId?: TableIdentity) {
+    const sku = await this.scope.model.sku.get({ code });
+    if (sku && String(sku.id) !== String(excludedId)) {
+      this.app.throw(409, `SKU code already exists: ${code}`);
+    }
+  }
+}

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

@@ -0,0 +1,358 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+
+async function createCatalog(
+  prefix: string,
+  lifecycle: 'draft' | 'active' | 'inactive' | 'archived',
+) {
+  await app.bean.passport.signinMock();
+  try {
+    const categoryId = await app.bean.executor.performAction('post', '/commerce/catalog/category', {
+      body: { name: `${prefix} category`, published: true },
+    });
+    const productId = await app.bean.executor.performAction('post', '/commerce/catalog/product', {
+      body: { categoryId, title: `${prefix} product`, published: true },
+    });
+    const skuId = await app.bean.executor.performAction('post', '/commerce/catalog/sku', {
+      body: { code: `${prefix}-sku`, productId, priceCents: 1299, lifecycle },
+    });
+    return { categoryId, productId, skuId };
+  } finally {
+    await app.bean.passport.signout();
+  }
+}
+
+describe('catalog.test.ts', () => {
+  it('enforces operator access and category/product relations', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      await app.bean.passport.signinMock();
+      try {
+        app.bean.passport.current!.roles = [];
+        const permissions = await Promise.all([
+          app.bean.permission.retrievePermissionAction('commerce-catalog:category', 'create'),
+          app.bean.permission.retrievePermissionAction('commerce-catalog:product', 'create'),
+          app.bean.permission.retrievePermissionAction('commerce-catalog:sku', 'create'),
+        ]);
+        assert.deepEqual(permissions, [false, false, false]);
+      } finally {
+        await app.bean.passport.signout();
+      }
+
+      await app.bean.passport.signinMock();
+      try {
+        await assert.rejects(() =>
+          app.bean.executor.performAction('post', '/commerce/catalog/product', {
+            body: { categoryId: 999999, title: 'Missing category', published: false },
+          }),
+        );
+      } finally {
+        await app.bean.passport.signout();
+      }
+    });
+  });
+
+  it('stores integer cents and exposes only sellable products to customers', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const active = await createCatalog('__catalog-active__', 'active');
+      const draft = await createCatalog('__catalog-draft__', 'draft');
+      const inactive = await createCatalog('__catalog-inactive__', 'inactive');
+      const archived = await createCatalog('__catalog-archived__', 'archived');
+      const unpublishedProduct = await createCatalog('__catalog-unpublished-product__', 'active');
+      const unpublishedCategory = await createCatalog('__catalog-unpublished-category__', 'active');
+      const zeroStock = await createCatalog('__catalog-zero-stock__', 'active');
+
+      for (const catalog of [
+        active,
+        draft,
+        inactive,
+        archived,
+        unpublishedProduct,
+        unpublishedCategory,
+      ]) {
+        await app.scope('commerce-trade').service.stockBalance.adjustStock({
+          skuId: catalog.skuId,
+          delta: 2,
+          reason: 'catalog public fixture',
+          correlationId: `catalog-public-${catalog.skuId}`,
+        });
+      }
+      await app.scope('commerce-catalog').model.product.updateById(unpublishedProduct.productId, {
+        published: false,
+      });
+      await app
+        .scope('commerce-catalog')
+        .model.category.updateById(unpublishedCategory.categoryId, {
+          published: false,
+        });
+
+      const publicProducts = await app.bean.executor.performAction(
+        'get',
+        '/commerce/catalog/product/public',
+        { innerAccess: false },
+      );
+      assert.equal(
+        publicProducts.list.some((product: any) => String(product.id) === String(active.productId)),
+        true,
+      );
+      for (const catalog of [
+        draft,
+        inactive,
+        archived,
+        unpublishedProduct,
+        unpublishedCategory,
+        zeroStock,
+      ]) {
+        assert.equal(
+          publicProducts.list.some(
+            (product: any) => String(product.id) === String(catalog.productId),
+          ),
+          false,
+        );
+      }
+      const catalogPublicProduct = publicProducts.list.find(
+        (product: any) => String(product.id) === String(active.productId),
+      );
+      assert.deepEqual(Object.keys(catalogPublicProduct).sort(), [
+        'available',
+        'categoryId',
+        'categoryName',
+        'description',
+        'id',
+        'priceCents',
+        'skuAvailables',
+        'title',
+      ]);
+      assert.equal(catalogPublicProduct.priceCents, 1299);
+      assert.equal(catalogPublicProduct.available, 2);
+      const publicProduct = await app.bean.executor.performAction(
+        'get',
+        '/commerce/catalog/product/public/:id',
+        { params: { id: active.productId }, innerAccess: false },
+      );
+      assert.equal(String(publicProduct.id), String(active.productId));
+      for (const catalog of [
+        draft,
+        inactive,
+        archived,
+        unpublishedProduct,
+        unpublishedCategory,
+        zeroStock,
+      ]) {
+        const publicProduct = await app.bean.executor.performAction(
+          'get',
+          '/commerce/catalog/product/public/:id',
+          { params: { id: catalog.productId }, innerAccess: false },
+        );
+        assert.equal(publicProduct, undefined);
+      }
+    });
+  });
+
+  it('paginates and aggregates public Products without duplicate roots', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const first = await createCatalog('__catalog-page-first__', 'active');
+      const second = await createCatalog('__catalog-page-second__', 'active');
+      const scopeCatalog = app.scope('commerce-catalog');
+      const additionalSku = await scopeCatalog.model.sku.insert({
+        code: '__catalog-page-first-additional-sku__',
+        productId: first.productId,
+        priceCents: 999,
+        lifecycle: 'active',
+      });
+      const inactiveSku = await scopeCatalog.model.sku.insert({
+        code: '__catalog-page-first-inactive-sku__',
+        productId: first.productId,
+        priceCents: 100,
+        lifecycle: 'inactive',
+      });
+      for (const [skuId, delta] of [
+        [first.skuId, 2],
+        [additionalSku.id, 3],
+        [inactiveSku.id, 4],
+        [second.skuId, 1],
+      ] as const) {
+        await app.scope('commerce-trade').service.stockBalance.adjustStock({
+          skuId,
+          delta,
+          reason: 'catalog pagination fixture',
+          correlationId: `catalog-pagination-${skuId}`,
+        });
+      }
+      const query = { title: '__catalog-page-', pageSize: 1 };
+      const pageOne = await app.bean.executor.performAction(
+        'get',
+        '/commerce/catalog/product/public',
+        {
+          query: { ...query, pageNo: 1 },
+          innerAccess: false,
+        },
+      );
+      const pageTwo = await app.bean.executor.performAction(
+        'get',
+        '/commerce/catalog/product/public',
+        {
+          query: { ...query, pageNo: 2 },
+          innerAccess: false,
+        },
+      );
+      assert.equal(pageOne.total, '2');
+      assert.equal(pageOne.pageCount, 2);
+      assert.equal(pageOne.pageSize, 1);
+      assert.equal(pageOne.pageNo, 1);
+      assert.equal(pageTwo.total, '2');
+      assert.equal(pageTwo.pageNo, 2);
+      assert.notEqual(String(pageOne.list[0].id), String(pageTwo.list[0].id));
+      const firstPublicProduct = [pageOne, pageTwo]
+        .flatMap(page => page.list)
+        .find(product => String(product.id) === String(first.productId));
+      assert.equal(firstPublicProduct.priceCents, 999);
+      assert.equal(firstPublicProduct.available, 5);
+      assert.deepEqual(
+        firstPublicProduct.skuAvailables.map(sku => String(sku.id)).sort(),
+        [first.skuId, additionalSku.id].map(String).sort(),
+      );
+      const categoryProducts = await app.bean.executor.performAction(
+        'get',
+        '/commerce/catalog/product/public',
+        {
+          query: { categoryId: first.categoryId },
+          innerAccess: false,
+        },
+      );
+      assert.equal(categoryProducts.total, '1');
+      assert.equal(String(categoryProducts.list[0].id), String(first.productId));
+    });
+  });
+
+  it('refreshes public eligibility after Category, SKU, and stock changes', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const catalog = await createCatalog('__catalog-cache__', 'active');
+      const query = { title: '__catalog-cache__' };
+      const selectPublic = async () => {
+        return await app.bean.executor.performAction('get', '/commerce/catalog/product/public', {
+          query,
+          innerAccess: false,
+        });
+      };
+      await app.scope('commerce-trade').service.stockBalance.adjustStock({
+        skuId: catalog.skuId,
+        delta: 1,
+        reason: 'catalog cache fixture',
+        correlationId: `catalog-cache-add-${catalog.skuId}`,
+      });
+      assert.equal((await selectPublic()).total, '1');
+      await app.scope('commerce-trade').service.stockBalance.adjustStock({
+        skuId: catalog.skuId,
+        delta: -1,
+        reason: 'catalog cache fixture',
+        correlationId: `catalog-cache-remove-${catalog.skuId}`,
+      });
+      assert.equal((await selectPublic()).total, '0');
+      await app.scope('commerce-trade').service.stockBalance.adjustStock({
+        skuId: catalog.skuId,
+        delta: 1,
+        reason: 'catalog cache fixture',
+        correlationId: `catalog-cache-restore-${catalog.skuId}`,
+      });
+      assert.equal((await selectPublic()).total, '1');
+      await app.scope('commerce-catalog').model.sku.updateById(catalog.skuId, {
+        lifecycle: 'inactive',
+      });
+      assert.equal((await selectPublic()).total, '0');
+      await app.scope('commerce-catalog').model.sku.updateById(catalog.skuId, {
+        lifecycle: 'active',
+      });
+      assert.equal((await selectPublic()).total, '1');
+      await app.scope('commerce-catalog').model.category.updateById(catalog.categoryId, {
+        published: false,
+      });
+      assert.equal((await selectPublic()).total, '0');
+    });
+  });
+
+  it('isolates catalog data and SKU uniqueness by tenant', async () => {
+    let defaultProductId: unknown;
+    await app.bean.executor.mockCtx(async () => {
+      const catalog = await createCatalog('__catalog-default__', 'active');
+      defaultProductId = catalog.productId;
+
+      await app.bean.passport.signinMock();
+      try {
+        await assert.rejects(() =>
+          app.bean.executor.performAction('post', '/commerce/catalog/sku', {
+            body: {
+              code: '__catalog-default__-sku',
+              productId: catalog.productId,
+              priceCents: 2000,
+              lifecycle: 'draft',
+            },
+          }),
+        );
+      } finally {
+        await app.bean.passport.signout();
+      }
+    });
+
+    await app.bean.executor.mockCtx(
+      async () => {
+        const catalog = await createCatalog('__catalog-share__', 'active');
+        await app.bean.passport.signinMock();
+        try {
+          const duplicateCodeSkuId = await app.bean.executor.performAction(
+            'post',
+            '/commerce/catalog/sku',
+            {
+              body: {
+                code: '__catalog-default__-sku',
+                productId: catalog.productId,
+                priceCents: 2500,
+                lifecycle: 'active',
+              },
+            },
+          );
+          assert.equal(!!duplicateCodeSkuId, true);
+        } finally {
+          await app.bean.passport.signout();
+        }
+
+        await app.scope('commerce-trade').service.stockBalance.adjustStock({
+          skuId: catalog.skuId,
+          delta: 1,
+          reason: 'catalog tenant fixture',
+          correlationId: `catalog-tenant-${catalog.skuId}`,
+        });
+        const publicProducts = await app.bean.executor.performAction(
+          'get',
+          '/commerce/catalog/product/public',
+          {
+            innerAccess: false,
+          },
+        );
+        assert.equal(
+          publicProducts.list.some(
+            (product: any) => String(product.id) === String(defaultProductId),
+          ),
+          false,
+        );
+        assert.equal(
+          publicProducts.list.some((product: any) => product.title === '__catalog-share__ product'),
+          true,
+        );
+        const foreignProduct = await app.bean.executor.performAction(
+          'get',
+          '/commerce/catalog/product/public/:id',
+          { params: { id: defaultProductId }, innerAccess: false },
+        );
+        assert.equal(foreignProduct, undefined);
+        const publicProduct = await app.bean.executor.performAction(
+          'get',
+          '/commerce/catalog/product/public/:id',
+          { params: { id: catalog.productId }, innerAccess: false },
+        );
+        assert.equal(String(publicProduct.id), String(catalog.productId));
+      },
+      { instanceName: 'shareTest' as any },
+    );
+  });
+});

package/vona/src/suite/a-commerce/modules/commerce-catalog/test/category.test.ts

@@ -0,0 +1,91 @@
+import type {
+  DtoCategoryCreate,
+  DtoCategorySelectRes,
+  DtoCategoryUpdate,
+  EntityCategory,
+} from 'vona-module-commerce-catalog';
+
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+
+describe('category.test.ts', () => {
+  it('action:category', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      // data
+      const data: DtoCategoryCreate = {
+        name: '__Tom__',
+        published: false,
+        description: 'This is a test',
+      };
+      const dataUpdate: DtoCategoryUpdate = {
+        name: '__TomNew__',
+        published: true,
+        description: 'This is a test',
+      };
+      // role-less authenticated users cannot access generated admin actions
+      await app.bean.passport.signinMock();
+      try {
+        app.bean.passport.current!.roles = [];
+        const actions = ['create', 'select', 'view', 'update', 'delete'];
+        const permissions = await Promise.all(
+          actions.map(action =>
+            app.bean.permission.retrievePermissionAction('commerce-catalog:category', action),
+          ),
+        );
+        assert.deepEqual(
+          permissions,
+          actions.map(() => false),
+        );
+      } finally {
+        await app.bean.passport.signout();
+      }
+      // login as system admin
+      await app.bean.passport.signinMock();
+      // create
+      const categoryId = await app.bean.executor.performAction(
+        'post',
+        '/commerce/catalog/category',
+        { body: data },
+      );
+      assert.equal(!!categoryId, true);
+      // findMany
+      const selectRes: DtoCategorySelectRes = await app.bean.executor.performAction(
+        'get',
+        '/commerce/catalog/category',
+      );
+      assert.equal(selectRes.list.findIndex(item => item.name === data.name) > -1, true);
+      // update
+      const updateRes = await app.bean.executor.performAction(
+        'patch',
+        '/commerce/catalog/category/:id',
+        {
+          params: { id: categoryId },
+          body: dataUpdate,
+        },
+      );
+      assert.equal(updateRes, null);
+      // findOne
+      let category: EntityCategory = await app.bean.executor.performAction(
+        'get',
+        '/commerce/catalog/category/:id',
+        { params: { id: categoryId } },
+      );
+      assert.equal(category.name, dataUpdate.name);
+      // delete
+      const deleteRes = await app.bean.executor.performAction(
+        'delete',
+        '/commerce/catalog/category/:id',
+        { params: { id: category.id } },
+      );
+      assert.equal(deleteRes, null);
+      // findOne
+      category = await app.bean.executor.performAction('get', '/commerce/catalog/category/:id', {
+        params: { id: category.id },
+      });
+      assert.equal(category, undefined);
+      // logout
+      await app.bean.passport.signout();
+    });
+  });
+});