@open-mercato/core 0.4.5-develop-2e9903a57a → 0.4.5-develop-eeccf7adf4

package/src/modules/business_rules/lib/__tests__/rule-evaluator.test.ts

@@ -1,436 +0,0 @@
-import { describe, test, expect } from '@jest/globals'
-import {
-  evaluate,
-  evaluateSingleRule,
-  evaluateConditions,
-  sortRulesByPriority,
-  filterRulesByContext,
-  getApplicableRules,
-  type RuleEvaluationContext,
-} from '../rule-evaluator'
-import type { BusinessRule } from '../../data/entities'
-
-describe('RuleEvaluatorService', () => {
-
-  // Helper to create test rules
-  const createTestRule = (overrides: Partial<BusinessRule> = {}): BusinessRule => {
-    return {
-      id: 'test-id',
-      ruleId: 'TEST-001',
-      ruleName: 'Test Rule',
-      ruleType: 'GUARD',
-      entityType: 'WorkOrder',
-      conditionExpression: { field: 'status', operator: '=', value: 'ACTIVE' },
-      enabled: true,
-      priority: 100,
-      version: 1,
-      tenantId: 'tenant-123',
-      organizationId: 'org-456',
-      createdAt: new Date(),
-      updatedAt: new Date(),
-      ...overrides,
-    } as BusinessRule
-  }
-
-  describe('evaluateSingleRule', () => {
-    test('should evaluate a simple rule successfully', async () => {
-      const rule = createTestRule({
-        conditionExpression: { field: 'status', operator: '=', value: 'ACTIVE' },
-      })
-
-      const result = await evaluateSingleRule(rule, { status: 'ACTIVE' }, {})
-
-      expect(result.conditionsPassed).toBe(true)
-      expect(result.evaluationCompleted).toBe(true)
-      expect(result.rule).toBe(rule)
-      expect(result.evaluationTime).toBeGreaterThanOrEqual(0)
-      expect(result.error).toBeUndefined()
-    })
-
-    test('should fail when conditions do not match', async () => {
-      const rule = createTestRule({
-        conditionExpression: { field: 'status', operator: '=', value: 'ACTIVE' },
-      })
-
-      const result = await evaluateSingleRule(rule, { status: 'INACTIVE' }, {})
-
-      expect(result.conditionsPassed).toBe(false)
-      expect(result.evaluationCompleted).toBe(true)  // Evaluation completed, conditions just didn't pass
-      expect(result.error).toBeUndefined()
-    })
-
-    test('should fail when rule is disabled', async () => {
-      const rule = createTestRule({
-        enabled: false,
-      })
-
-      const result = await evaluateSingleRule(rule, { status: 'ACTIVE' }, {})
-
-      expect(result.conditionsPassed).toBe(false)
-      expect(result.evaluationCompleted).toBe(false)
-      expect(result.error).toBe('Rule is disabled')
-    })
-
-    test('should fail when rule is not yet effective', async () => {
-      const future = new Date(Date.now() + 86400000) // Tomorrow
-      const rule = createTestRule({
-        effectiveFrom: future,
-      })
-
-      const result = await evaluateSingleRule(rule, { status: 'ACTIVE' }, {})
-
-      expect(result.conditionsPassed).toBe(false)
-      expect(result.evaluationCompleted).toBe(false)
-      expect(result.error).toBe('Rule is not effective (outside date range)')
-    })
-
-    test('should fail when rule has expired', async () => {
-      const past = new Date(Date.now() - 86400000) // Yesterday
-      const rule = createTestRule({
-        effectiveTo: past,
-      })
-
-      const result = await evaluateSingleRule(rule, { status: 'ACTIVE' }, {})
-
-      expect(result.conditionsPassed).toBe(false)
-      expect(result.evaluationCompleted).toBe(false)
-      expect(result.error).toBe('Rule is not effective (outside date range)')
-    })
-
-    test('should succeed when rule is within effective date range', async () => {
-      const yesterday = new Date(Date.now() - 86400000)
-      const tomorrow = new Date(Date.now() + 86400000)
-      const rule = createTestRule({
-        effectiveFrom: yesterday,
-        effectiveTo: tomorrow,
-        conditionExpression: { field: 'status', operator: '=', value: 'ACTIVE' },
-      })
-
-      const result = await evaluateSingleRule(rule, { status: 'ACTIVE' }, {})
-
-      expect(result.conditionsPassed).toBe(true)
-      expect(result.evaluationCompleted).toBe(true)
-    })
-
-    test('should handle complex AND conditions', async () => {
-      const rule = createTestRule({
-        conditionExpression: {
-          operator: 'AND',
-          rules: [
-            { field: 'quantity', operator: '>', value: 0 },
-            { field: 'status', operator: '=', value: 'ACTIVE' },
-          ],
-        },
-      })
-
-      const result = await evaluateSingleRule(rule, { quantity: 10, status: 'ACTIVE' }, {})
-
-      expect(result.conditionsPassed).toBe(true)
-      expect(result.evaluationCompleted).toBe(true)
-    })
-
-    test('should handle complex OR conditions', async () => {
-      const rule = createTestRule({
-        conditionExpression: {
-          operator: 'OR',
-          rules: [
-            { field: 'priority', operator: '=', value: 'HIGH' },
-            { field: 'urgent', operator: '=', value: true },
-          ],
-        },
-      })
-
-      const result = await evaluateSingleRule(rule, { priority: 'LOW', urgent: true }, {})
-
-      expect(result.conditionsPassed).toBe(true)
-      expect(result.evaluationCompleted).toBe(true)
-    })
-
-    test('should pass when conditions are null (always true)', async () => {
-      const rule = createTestRule({
-        conditionExpression: null as any,
-      })
-
-      const result = await evaluateSingleRule(rule, {}, {})
-
-      expect(result.conditionsPassed).toBe(true)
-      expect(result.evaluationCompleted).toBe(true)
-    })
-
-    test('should handle evaluation errors gracefully', async () => {
-      const rule = createTestRule({
-        conditionExpression: { field: 'value', operator: 'INVALID_OPERATOR' as any, value: 10 },
-      })
-
-      const result = await evaluateSingleRule(rule, { value: 10 }, {})
-
-      expect(result.conditionsPassed).toBe(false)
-      expect(result.evaluationCompleted).toBe(false)
-      expect(result.error).toContain('Unknown operator')
-    })
-  })
-
-  describe('evaluateConditions', () => {
-    test('should evaluate simple conditions', async () => {
-      const conditions = { field: 'status', operator: '=', value: 'ACTIVE' }
-      const result = await evaluateConditions(conditions, { status: 'ACTIVE' }, {})
-
-      expect(result).toBe(true)
-    })
-
-    test('should evaluate group conditions', async () => {
-      const conditions = {
-        operator: 'AND',
-        rules: [
-          { field: 'quantity', operator: '>', value: 0 },
-          { field: 'price', operator: '<=', value: 100 },
-        ],
-      }
-      const result = await evaluateConditions(conditions, { quantity: 10, price: 50 }, {})
-
-      expect(result).toBe(true)
-    })
-
-    test('should return true when conditions are null', async () => {
-      const result = await evaluateConditions(null, {}, {})
-
-      expect(result).toBe(true)
-    })
-
-    test('should throw error on invalid conditions', async () => {
-      const conditions = { field: 'value', operator: 'INVALID' as any, value: 10 }
-
-      await expect(evaluateConditions(conditions, { value: 10 }, {})).rejects.toThrow('Condition evaluation failed')
-    })
-  })
-
-  describe('evaluate (multiple rules)', () => {
-    test('should evaluate multiple rules and return results', async () => {
-      const rules = [
-        createTestRule({
-          ruleId: 'RULE-001',
-          conditionExpression: { field: 'quantity', operator: '>', value: 0 },
-        }),
-        createTestRule({
-          ruleId: 'RULE-002',
-          conditionExpression: { field: 'status', operator: '=', value: 'ACTIVE' },
-        }),
-      ]
-
-      const result = await evaluate(rules, { quantity: 10, status: 'ACTIVE' }, {})
-
-      expect(result.conditionsPassed).toBe(true)
-      expect(result.evaluationCompleted).toBe(true)
-      expect(result.matchedRules).toHaveLength(2)
-      expect(result.failedRules).toHaveLength(0)
-      expect(result.evaluationTime).toBeGreaterThanOrEqual(0)
-    })
-
-    test('should separate matched and failed rules', async () => {
-      const rules = [
-        createTestRule({
-          ruleId: 'RULE-001',
-          conditionExpression: { field: 'quantity', operator: '>', value: 0 },
-        }),
-        createTestRule({
-          ruleId: 'RULE-002',
-          conditionExpression: { field: 'status', operator: '=', value: 'DELETED' },
-        }),
-      ]
-
-      const result = await evaluate(rules, { quantity: 10, status: 'ACTIVE' }, {})
-
-      expect(result.conditionsPassed).toBe(true)
-      expect(result.evaluationCompleted).toBe(true)
-      expect(result.matchedRules).toHaveLength(1)
-      expect(result.matchedRules[0].ruleId).toBe('RULE-001')
-      expect(result.failedRules).toHaveLength(1)
-      expect(result.failedRules[0].ruleId).toBe('RULE-002')
-    })
-
-    test('should collect errors from failed rules', async () => {
-      const rules = [
-        createTestRule({
-          ruleId: 'RULE-001',
-          enabled: false,
-        }),
-        createTestRule({
-          ruleId: 'RULE-002',
-          conditionExpression: { field: 'value', operator: 'INVALID' as any, value: 10 },
-        }),
-      ]
-
-      const result = await evaluate(rules, { value: 10 }, {})
-
-      expect(result.conditionsPassed).toBe(false)
-      expect(result.evaluationCompleted).toBe(false)
-      expect(result.errors).toBeDefined()
-      expect(result.errors?.length).toBe(2)
-      expect(result.errors?.[0]).toContain('RULE-001')
-      expect(result.errors?.[1]).toContain('RULE-002')
-    })
-
-    test('should evaluate rules in priority order', async () => {
-      const executionOrder: string[] = []
-
-      const rules = [
-        createTestRule({
-          ruleId: 'LOW',
-          priority: 50,
-          conditionExpression: { field: 'always', operator: '=', value: true },
-        }),
-        createTestRule({
-          ruleId: 'HIGH',
-          priority: 200,
-          conditionExpression: { field: 'always', operator: '=', value: true },
-        }),
-        createTestRule({
-          ruleId: 'MEDIUM',
-          priority: 100,
-          conditionExpression: { field: 'always', operator: '=', value: true },
-        }),
-      ]
-
-      const result = await evaluate(rules, { always: true }, {})
-
-      // Check that rules were matched in priority order
-      expect(result.matchedRules[0].ruleId).toBe('HIGH')
-      expect(result.matchedRules[1].ruleId).toBe('MEDIUM')
-      expect(result.matchedRules[2].ruleId).toBe('LOW')
-    })
-  })
-
-  describe('sortRulesByPriority', () => {
-    test('should sort rules by priority (highest first)', () => {
-      const rules = [
-        createTestRule({ ruleId: 'LOW', priority: 50 }),
-        createTestRule({ ruleId: 'HIGH', priority: 200 }),
-        createTestRule({ ruleId: 'MEDIUM', priority: 100 }),
-      ]
-
-      const sorted = sortRulesByPriority(rules)
-
-      expect(sorted[0].ruleId).toBe('HIGH')
-      expect(sorted[1].ruleId).toBe('MEDIUM')
-      expect(sorted[2].ruleId).toBe('LOW')
-    })
-
-    test('should sort by ruleId when priority is the same', () => {
-      const rules = [
-        createTestRule({ ruleId: 'RULE-C', priority: 100 }),
-        createTestRule({ ruleId: 'RULE-A', priority: 100 }),
-        createTestRule({ ruleId: 'RULE-B', priority: 100 }),
-      ]
-
-      const sorted = sortRulesByPriority(rules)
-
-      expect(sorted[0].ruleId).toBe('RULE-A')
-      expect(sorted[1].ruleId).toBe('RULE-B')
-      expect(sorted[2].ruleId).toBe('RULE-C')
-    })
-
-    test('should not mutate original array', () => {
-      const rules = [
-        createTestRule({ ruleId: 'LOW', priority: 50 }),
-        createTestRule({ ruleId: 'HIGH', priority: 200 }),
-      ]
-
-      const originalOrder = rules.map((r) => r.ruleId)
-      sortRulesByPriority(rules)
-
-      expect(rules.map((r) => r.ruleId)).toEqual(originalOrder)
-    })
-  })
-
-  describe('filterRulesByContext', () => {
-    test('should filter by entity type', () => {
-      const rules = [
-        createTestRule({ ruleId: 'RULE-1', entityType: 'WorkOrder' }),
-        createTestRule({ ruleId: 'RULE-2', entityType: 'Item' }),
-        createTestRule({ ruleId: 'RULE-3', entityType: 'WorkOrder' }),
-      ]
-
-      const filtered = filterRulesByContext(rules, 'WorkOrder')
-
-      expect(filtered).toHaveLength(2)
-      expect(filtered[0].ruleId).toBe('RULE-1')
-      expect(filtered[1].ruleId).toBe('RULE-3')
-    })
-
-    test('should filter by event type', () => {
-      const rules = [
-        createTestRule({ ruleId: 'RULE-1', eventType: 'beforeSave' }),
-        createTestRule({ ruleId: 'RULE-2', eventType: 'afterSave' }),
-        createTestRule({ ruleId: 'RULE-3', eventType: null }),
-      ]
-
-      const filtered = filterRulesByContext(rules, undefined, 'beforeSave')
-
-      // RULE-1 matches, RULE-3 has no event type so it passes
-      expect(filtered).toHaveLength(2)
-      expect(filtered.map((r) => r.ruleId)).toContain('RULE-1')
-      expect(filtered.map((r) => r.ruleId)).toContain('RULE-3')
-    })
-
-    test('should filter by both entity type and event type', () => {
-      const rules = [
-        createTestRule({ ruleId: 'RULE-1', entityType: 'WorkOrder', eventType: 'beforeSave' }),
-        createTestRule({ ruleId: 'RULE-2', entityType: 'Item', eventType: 'beforeSave' }),
-        createTestRule({ ruleId: 'RULE-3', entityType: 'WorkOrder', eventType: 'afterSave' }),
-        createTestRule({ ruleId: 'RULE-4', entityType: 'WorkOrder', eventType: null }),
-      ]
-
-      const filtered = filterRulesByContext(rules, 'WorkOrder', 'beforeSave')
-
-      expect(filtered).toHaveLength(2)
-      expect(filtered.map((r) => r.ruleId)).toContain('RULE-1')
-      expect(filtered.map((r) => r.ruleId)).toContain('RULE-4')
-    })
-
-    test('should return all rules when no filters provided', () => {
-      const rules = [
-        createTestRule({ ruleId: 'RULE-1' }),
-        createTestRule({ ruleId: 'RULE-2' }),
-      ]
-
-      const filtered = filterRulesByContext(rules)
-
-      expect(filtered).toHaveLength(2)
-    })
-  })
-
-  describe('getApplicableRules', () => {
-    test('should return enabled, effective, and sorted rules', () => {
-      const yesterday = new Date(Date.now() - 86400000)
-      const tomorrow = new Date(Date.now() + 86400000)
-
-      const rules = [
-        createTestRule({ ruleId: 'RULE-1', priority: 100, enabled: true }),
-        createTestRule({ ruleId: 'RULE-2', priority: 200, enabled: false }), // Disabled
-        createTestRule({ ruleId: 'RULE-3', priority: 150, effectiveFrom: tomorrow }), // Not yet effective
-        createTestRule({ ruleId: 'RULE-4', priority: 50, effectiveTo: yesterday }), // Expired
-        createTestRule({ ruleId: 'RULE-5', priority: 300, enabled: true }),
-      ]
-
-      const applicable = getApplicableRules(rules)
-
-      expect(applicable).toHaveLength(2)
-      expect(applicable[0].ruleId).toBe('RULE-5') // Highest priority
-      expect(applicable[1].ruleId).toBe('RULE-1')
-    })
-
-    test('should filter by entity type and event type', () => {
-      const rules = [
-        createTestRule({ ruleId: 'RULE-1', entityType: 'WorkOrder', priority: 100 }),
-        createTestRule({ ruleId: 'RULE-2', entityType: 'Item', priority: 200 }),
-        createTestRule({ ruleId: 'RULE-3', entityType: 'WorkOrder', priority: 150 }),
-      ]
-
-      const applicable = getApplicableRules(rules, 'WorkOrder')
-
-      expect(applicable).toHaveLength(2)
-      expect(applicable[0].ruleId).toBe('RULE-3') // Higher priority
-      expect(applicable[1].ruleId).toBe('RULE-1')
-    })
-  })
-})

package/src/modules/catalog/__integration__/TC-CAT-001.spec.ts

@@ -1,32 +0,0 @@
-import { expect, test } from '@playwright/test';
-import { login } from '@open-mercato/core/modules/core/__integration__/helpers/auth';
-
-/**
- * TC-CAT-001: Create New Product
- * Source: .ai/qa/scenarios/TC-CAT-001-product-creation.md
- */
-test.describe('TC-CAT-001: Create New Product', () => {
-  test('should create a product from catalog create form', async ({ page }) => {
-    const productName = `QA TC-CAT-001 ${Date.now()}`;
-    const sku = `QA-CAT-001-${Date.now()}`;
-
-    await login(page, 'admin');
-    await page.goto('/backend/catalog/products/create');
-
-    await page.getByRole('textbox', { name: 'e.g., Summer sneaker' }).fill(productName);
-    await page
-      .getByRole('textbox', { name: 'Describe the product...' })
-      .fill('This is a catalog QA description long enough to satisfy SEO validation checks in create flow.');
-
-    await page.getByRole('button', { name: 'Variants' }).click();
-    await page.getByRole('textbox', { name: 'e.g., SKU-001' }).fill(sku);
-
-    await page.getByRole('button', { name: 'Create product' }).last().click();
-    await expect(page).toHaveURL(/\/backend\/catalog\/products$/);
-
-    const search = page.getByRole('textbox', { name: 'Search' });
-    await search.fill(productName);
-    await expect(page.getByText(productName, { exact: true })).toBeVisible();
-  });
-});
-

package/src/modules/catalog/__integration__/TC-CAT-002.spec.ts

@@ -1,19 +0,0 @@
-import { expect, test } from '@playwright/test';
-import { login } from '@open-mercato/core/modules/core/__integration__/helpers/auth';
-
-/**
- * TC-CAT-002: Product Creation Validation Errors
- * Source: .ai/qa/scenarios/TC-CAT-002-product-creation-validation.md
- */
-test.describe('TC-CAT-002: Product Creation Validation Errors', () => {
-  test('should block save when required title is missing', async ({ page }) => {
-    await login(page, 'admin');
-    await page.goto('/backend/catalog/products/create');
-
-    await page.getByRole('button', { name: 'Create product' }).last().click();
-
-    await expect(page.getByText(/required/i)).toBeVisible();
-    await expect(page).toHaveURL(/\/backend\/catalog\/products\/create$/);
-  });
-});
-

package/src/modules/catalog/__integration__/TC-CAT-003.spec.ts

@@ -1,39 +0,0 @@
-import { expect, test } from '@playwright/test';
-import { login } from '@open-mercato/core/modules/core/__integration__/helpers/auth';
-
-/**
- * TC-CAT-003: Edit Existing Product
- * Source: .ai/qa/scenarios/TC-CAT-003-product-edit.md
- */
-test.describe('TC-CAT-003: Edit Existing Product', () => {
-  test('should edit product title and persist it', async ({ page }) => {
-    const productName = `QA TC-CAT-003 ${Date.now()}`;
-    const updatedName = `${productName} Updated`;
-    const sku = `QA-CAT-003-${Date.now()}`;
-
-    await login(page, 'admin');
-    await page.goto('/backend/catalog/products/create');
-    await page.getByRole('textbox', { name: 'e.g., Summer sneaker' }).fill(productName);
-    await page
-      .getByRole('textbox', { name: 'Describe the product...' })
-      .fill('This is a catalog QA description long enough to satisfy SEO validation checks in create flow.');
-    await page.getByRole('button', { name: 'Variants' }).click();
-    await page.getByRole('textbox', { name: 'e.g., SKU-001' }).fill(sku);
-    await page.getByRole('button', { name: 'Create product' }).last().click();
-
-    await expect(page).toHaveURL(/\/backend\/catalog\/products$/);
-    const search = page.getByRole('textbox', { name: 'Search' });
-    await search.fill(productName);
-    await page.getByText(productName, { exact: true }).first().click();
-
-    await expect(page).toHaveURL(/\/backend\/catalog\/products\/[0-9a-f-]{36}$/i);
-    const titleField = page.getByRole('textbox', { name: 'e.g., Summer sneaker' });
-    await titleField.fill(updatedName);
-    await page.getByRole('button', { name: 'Save changes' }).last().click();
-
-    await expect(page).toHaveURL(/\/backend\/catalog\/products$/);
-    await search.fill(updatedName);
-    await expect(page.getByText(updatedName, { exact: true })).toBeVisible();
-  });
-});
-

package/src/modules/catalog/__integration__/TC-CAT-004.spec.ts

@@ -1,41 +0,0 @@
-import { expect, test } from '@playwright/test';
-import { createProductFixture, deleteCatalogProductIfExists } from '@open-mercato/core/modules/core/__integration__/helpers/catalogFixtures';
-import { getAuthToken } from '@open-mercato/core/modules/core/__integration__/helpers/api';
-import { login } from '@open-mercato/core/modules/core/__integration__/helpers/auth';
-
-/**
- * TC-CAT-004: Delete Product
- * Source: .ai/qa/scenarios/TC-CAT-004-product-delete.md
- */
-test.describe('TC-CAT-004: Delete Product', () => {
-  test('should open delete confirmation for the default variant', async ({ page, request }) => {
-    const productName = `QA TC-CAT-004 ${Date.now()}`;
-    const sku = `QA-CAT-004-BASE-${Date.now()}`;
-    let token: string | null = null;
-    let productId: string | null = null;
-
-    try {
-      token = await getAuthToken(request);
-      productId = await createProductFixture(request, token, { title: productName, sku });
-
-      await login(page, 'admin');
-      await page.goto(`/backend/catalog/products/${productId}`);
-
-      await page.getByRole('link', { name: 'Add variant' }).click();
-      await expect(page).toHaveURL(/\/variants\/create$/);
-      await page.getByRole('textbox', { name: 'e.g., Blue / Small' }).fill('Delete Me Variant');
-      await page.getByRole('textbox', { name: 'Unique identifier' }).fill(`QA-CAT-004-VAR-${Date.now()}`);
-      await page.getByRole('button', { name: 'Create variant' }).last().click();
-      await expect(page).toHaveURL(/\/variants\/[0-9a-f-]{36}$/i);
-
-      await page.goto(`/backend/catalog/products/${productId}`);
-      await page.getByRole('button', { name: /^Delete$/i }).first().click();
-      const confirmDialog = page.getByRole('alertdialog');
-      await expect(confirmDialog).toBeVisible();
-      await expect(confirmDialog.getByRole('heading', { name: /Delete variant/i })).toBeVisible();
-      await expect(confirmDialog.getByRole('button', { name: 'Confirm' })).toBeVisible();
-    } finally {
-      await deleteCatalogProductIfExists(request, token, productId);
-    }
-  });
-});

package/src/modules/catalog/__integration__/TC-CAT-005.spec.ts

@@ -1,37 +0,0 @@
-import { expect, test } from '@playwright/test';
-import { createProductFixture, deleteCatalogProductIfExists } from '@open-mercato/core/modules/core/__integration__/helpers/catalogFixtures';
-import { getAuthToken } from '@open-mercato/core/modules/core/__integration__/helpers/api';
-import { login } from '@open-mercato/core/modules/core/__integration__/helpers/auth';
-
-/**
- * TC-CAT-005: Create Product Variant
- * Source: .ai/qa/scenarios/TC-CAT-005-product-variant-creation.md
- */
-test.describe('TC-CAT-005: Create Product Variant', () => {
-  test('should create an additional variant for a product', async ({ page, request }) => {
-    const productName = `QA TC-CAT-005 ${Date.now()}`;
-    const baseSku = `QA-CAT-005-BASE-${Date.now()}`;
-    const variantName = `Blue / 42 ${Date.now()}`;
-    const variantSku = `QA-CAT-005-VAR-${Date.now()}`;
-    let token: string | null = null;
-    let productId: string | null = null;
-
-    try {
-      token = await getAuthToken(request);
-      productId = await createProductFixture(request, token, { title: productName, sku: baseSku });
-
-      await login(page, 'admin');
-      await page.goto(`/backend/catalog/products/${productId}/variants/create`);
-      await expect(page).toHaveURL(/\/variants\/create$/);
-      await page.getByRole('textbox', { name: 'e.g., Blue / Small' }).fill(variantName);
-      await page.getByRole('textbox', { name: 'Unique identifier' }).fill(variantSku);
-      await page.getByRole('button', { name: 'Create variant' }).last().click();
-
-      await expect(page).toHaveURL(/\/backend\/catalog\/products\/[0-9a-f-]{36}\/variants\/[0-9a-f-]{36}$/i);
-      await expect(page.getByRole('textbox', { name: 'e.g., Blue / Small' })).toHaveValue(variantName);
-      await expect(page.getByRole('textbox', { name: 'Unique identifier' })).toHaveValue(variantSku);
-    } finally {
-      await deleteCatalogProductIfExists(request, token, productId);
-    }
-  });
-});

package/src/modules/catalog/__integration__/TC-CAT-006.spec.ts

@@ -1,40 +0,0 @@
-import { expect, test } from '@playwright/test';
-import { createProductFixture, deleteCatalogProductIfExists } from '@open-mercato/core/modules/core/__integration__/helpers/catalogFixtures';
-import { getAuthToken } from '@open-mercato/core/modules/core/__integration__/helpers/api';
-import { login } from '@open-mercato/core/modules/core/__integration__/helpers/auth';
-
-/**
- * TC-CAT-006: Edit Product Variant
- * Source: .ai/qa/scenarios/TC-CAT-006-product-variant-edit.md
- */
-test.describe('TC-CAT-006: Edit Product Variant', () => {
-  test('should edit default variant SKU and persist change', async ({ page, request }) => {
-    const productName = `QA TC-CAT-006 ${Date.now()}`;
-    const baseSku = `QA-CAT-006-BASE-${Date.now()}`;
-    const updatedSku = `QA-CAT-006-UPD-${Date.now()}`;
-    let token: string | null = null;
-    let productId: string | null = null;
-
-    try {
-      token = await getAuthToken(request);
-      productId = await createProductFixture(request, token, { title: productName, sku: baseSku });
-
-      await login(page, 'admin');
-      await page.goto(`/backend/catalog/products/${productId}`);
-
-      await page.getByRole('link', { name: 'Add variant' }).click();
-      await expect(page).toHaveURL(/\/variants\/create$/);
-      await page.getByRole('textbox', { name: 'e.g., Blue / Small' }).fill('Editable Variant');
-      await page.getByRole('textbox', { name: 'Unique identifier' }).fill(baseSku);
-      await page.getByRole('button', { name: 'Create variant' }).last().click();
-      await expect(page).toHaveURL(/\/variants\/[0-9a-f-]{36}$/i);
-
-      await page.getByRole('textbox', { name: 'Unique identifier' }).fill(updatedSku);
-      await page.getByRole('button', { name: 'Save changes' }).last().click();
-
-      await expect(page.getByText(updatedSku, { exact: true })).toBeVisible();
-    } finally {
-      await deleteCatalogProductIfExists(request, token, productId);
-    }
-  });
-});