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

package/src/modules/currencies/services/__tests__/rateFetchingService.providers.test.ts

@@ -1,350 +0,0 @@
-import { describe, it, expect, jest, beforeEach } from '@jest/globals'
-import { RateFetchingService } from '../rateFetchingService'
-import {
-  createMockEntityManager,
-  createMockProvider,
-  createTestCurrency,
-  createTestRate,
-  TEST_SCOPE,
-  TEST_DATE,
-} from './rateFetchingService.setup'
-
-describe('RateFetchingService - Provider Management', () => {
-  let service: RateFetchingService
-  
-  beforeEach(() => {
-    jest.clearAllMocks()
-  })
-
-  describe('provider selection', () => {
-    it('uses all registered providers by default', async () => {
-      // Setup
-      const currencies = [
-        createTestCurrency({ code: 'USD' }),
-        createTestCurrency({ code: 'EUR' }),
-      ]
-      
-      const { em } = createMockEntityManager({ currencies })
-      service = new RateFetchingService(em)
-      
-      const provider1 = createMockProvider({
-        source: 'PROVIDER1',
-        rates: [createTestRate({ fromCurrencyCode: 'USD', toCurrencyCode: 'EUR' })],
-      })
-      
-      const provider2 = createMockProvider({
-        source: 'PROVIDER2',
-        rates: [createTestRate({ fromCurrencyCode: 'EUR', toCurrencyCode: 'USD' })],
-      })
-      
-      service.registerProvider(provider1)
-      service.registerProvider(provider2)
-      
-      // Execute - no providers specified in options
-      const result = await service.fetchRatesForDate(TEST_DATE, TEST_SCOPE)
-      
-      // Assert - both providers should be called
-      expect(provider1.fetchRates).toHaveBeenCalled()
-      expect(provider2.fetchRates).toHaveBeenCalled()
-      expect(result.totalFetched).toBe(2)
-    })
-
-    it('uses only specified providers when options.providers is set', async () => {
-      // Setup
-      const currencies = [
-        createTestCurrency({ code: 'USD' }),
-        createTestCurrency({ code: 'EUR' }),
-      ]
-      
-      const { em } = createMockEntityManager({ currencies })
-      service = new RateFetchingService(em)
-      
-      const provider1 = createMockProvider({
-        source: 'PROVIDER1',
-        rates: [createTestRate({ fromCurrencyCode: 'USD', toCurrencyCode: 'EUR' })],
-      })
-      
-      const provider2 = createMockProvider({
-        source: 'PROVIDER2',
-        rates: [createTestRate({ fromCurrencyCode: 'EUR', toCurrencyCode: 'USD' })],
-      })
-      
-      service.registerProvider(provider1)
-      service.registerProvider(provider2)
-      
-      // Execute - only request PROVIDER1
-      const result = await service.fetchRatesForDate(TEST_DATE, TEST_SCOPE, {
-        providers: ['PROVIDER1'],
-      })
-      
-      // Assert - only PROVIDER1 should be called
-      expect(provider1.fetchRates).toHaveBeenCalled()
-      expect(provider2.fetchRates).not.toHaveBeenCalled()
-      expect(result.totalFetched).toBe(1)
-      expect(result.byProvider['PROVIDER1']).toBeDefined()
-      expect(result.byProvider['PROVIDER2']).toBeUndefined()
-    })
-
-    it('handles unknown provider names gracefully', async () => {
-      // Setup
-      const currencies = [createTestCurrency({ code: 'USD' })]
-      const { em } = createMockEntityManager({ currencies })
-      service = new RateFetchingService(em)
-      
-      const provider = createMockProvider({
-        source: 'KNOWN',
-        rates: [],
-      })
-      
-      service.registerProvider(provider)
-      
-      // Execute - request an unknown provider
-      const result = await service.fetchRatesForDate(TEST_DATE, TEST_SCOPE, {
-        providers: ['UNKNOWN'],
-      })
-      
-      // Assert
-      expect(result.errors).toContain('Unknown provider: UNKNOWN')
-      expect(result.totalFetched).toBe(0)
-      expect(provider.fetchRates).not.toHaveBeenCalled()
-    })
-
-    it('processes valid providers even with unknown ones in list', async () => {
-      // Setup
-      const currencies = [
-        createTestCurrency({ code: 'USD' }),
-        createTestCurrency({ code: 'EUR' }),
-      ]
-      
-      const { em } = createMockEntityManager({ currencies })
-      service = new RateFetchingService(em)
-      
-      const knownProvider = createMockProvider({
-        source: 'KNOWN',
-        rates: [createTestRate({ fromCurrencyCode: 'USD', toCurrencyCode: 'EUR' })],
-      })
-      
-      service.registerProvider(knownProvider)
-      
-      // Execute - mix of unknown and known providers
-      const result = await service.fetchRatesForDate(TEST_DATE, TEST_SCOPE, {
-        providers: ['UNKNOWN1', 'KNOWN', 'UNKNOWN2'],
-      })
-      
-      // Assert
-      expect(result.errors).toContain('Unknown provider: UNKNOWN1')
-      expect(result.errors).toContain('Unknown provider: UNKNOWN2')
-      expect(result.totalFetched).toBe(1) // From KNOWN provider
-      expect(knownProvider.fetchRates).toHaveBeenCalled()
-      expect(result.byProvider['KNOWN']).toEqual({ count: 1 })
-    })
-  })
-
-  describe('provider availability', () => {
-    it('skips providers that report isAvailable() === false', async () => {
-      // Setup
-      const currencies = [createTestCurrency({ code: 'USD' })]
-      const { em } = createMockEntityManager({ currencies })
-      service = new RateFetchingService(em)
-      
-      const unavailableProvider = createMockProvider({
-        source: 'UNAVAILABLE',
-        isAvailable: false,
-        rates: [createTestRate()],
-      })
-      
-      service.registerProvider(unavailableProvider)
-      
-      // Execute
-      const result = await service.fetchRatesForDate(TEST_DATE, TEST_SCOPE)
-      
-      // Assert
-      expect(unavailableProvider.isAvailable).toHaveBeenCalled()
-      expect(unavailableProvider.fetchRates).not.toHaveBeenCalled()
-      expect(result.totalFetched).toBe(0)
-    })
-
-    it('adds error for unavailable providers', async () => {
-      // Setup
-      const currencies = [createTestCurrency({ code: 'USD' })]
-      const { em } = createMockEntityManager({ currencies })
-      service = new RateFetchingService(em)
-      
-      const unavailableProvider = createMockProvider({
-        source: 'OFFLINE',
-        isAvailable: false,
-        rates: [],
-      })
-      
-      service.registerProvider(unavailableProvider)
-      
-      // Execute
-      const result = await service.fetchRatesForDate(TEST_DATE, TEST_SCOPE)
-      
-      // Assert
-      expect(result.errors).toContain('Provider not available: OFFLINE')
-    })
-
-    it('processes available providers when some are unavailable', async () => {
-      // Setup
-      const currencies = [
-        createTestCurrency({ code: 'USD' }),
-        createTestCurrency({ code: 'EUR' }),
-      ]
-      
-      const { em } = createMockEntityManager({ currencies })
-      service = new RateFetchingService(em)
-      
-      const unavailableProvider = createMockProvider({
-        source: 'UNAVAILABLE',
-        isAvailable: false,
-        rates: [],
-      })
-      
-      const availableProvider = createMockProvider({
-        source: 'AVAILABLE',
-        isAvailable: true,
-        rates: [createTestRate({ fromCurrencyCode: 'USD', toCurrencyCode: 'EUR' })],
-      })
-      
-      service.registerProvider(unavailableProvider)
-      service.registerProvider(availableProvider)
-      
-      // Execute
-      const result = await service.fetchRatesForDate(TEST_DATE, TEST_SCOPE)
-      
-      // Assert
-      expect(unavailableProvider.fetchRates).not.toHaveBeenCalled()
-      expect(availableProvider.fetchRates).toHaveBeenCalled()
-      expect(result.totalFetched).toBe(1)
-      expect(result.errors).toContain('Provider not available: UNAVAILABLE')
-    })
-
-    it('calls isAvailable() for each provider before fetching', async () => {
-      // Setup
-      const currencies = [createTestCurrency({ code: 'USD' })]
-      const { em } = createMockEntityManager({ currencies })
-      service = new RateFetchingService(em)
-      
-      const provider1 = createMockProvider({
-        source: 'PROVIDER1',
-        isAvailable: true,
-        rates: [],
-      })
-      
-      const provider2 = createMockProvider({
-        source: 'PROVIDER2',
-        isAvailable: true,
-        rates: [],
-      })
-      
-      service.registerProvider(provider1)
-      service.registerProvider(provider2)
-      
-      // Execute
-      await service.fetchRatesForDate(TEST_DATE, TEST_SCOPE)
-      
-      // Assert
-      expect(provider1.isAvailable).toHaveBeenCalled()
-      expect(provider2.isAvailable).toHaveBeenCalled()
-    })
-  })
-
-  describe('registerProvider', () => {
-    it('registers providers for fetching rates', async () => {
-      // Setup
-      const currencies = [
-        createTestCurrency({ code: 'USD' }),
-        createTestCurrency({ code: 'EUR' }),
-      ]
-      
-      const { em } = createMockEntityManager({ currencies })
-      service = new RateFetchingService(em)
-      
-      // Service starts with no providers
-      // Register custom test providers
-      const customProvider = createMockProvider({
-        source: 'CUSTOM',
-        rates: [createTestRate({ fromCurrencyCode: 'USD', toCurrencyCode: 'EUR' })],
-      })
-      
-      service.registerProvider(customProvider)
-      
-      // Execute
-      const result = await service.fetchRatesForDate(TEST_DATE, TEST_SCOPE)
-      
-      // Assert - custom provider should be used
-      expect(customProvider.fetchRates).toHaveBeenCalled()
-      expect(result.byProvider['CUSTOM']).toBeDefined()
-      expect(Object.keys(result.byProvider)).toEqual(['CUSTOM'])
-    })
-
-    it('allows registering multiple providers', async () => {
-      // Setup
-      const currencies = [createTestCurrency({ code: 'USD' })]
-      const { em } = createMockEntityManager({ currencies })
-      service = new RateFetchingService(em)
-      
-      const firstProvider = createMockProvider({
-        source: 'FIRST',
-        rates: [],
-      })
-      
-      const secondProvider = createMockProvider({
-        source: 'SECOND',
-        rates: [],
-      })
-      
-      // Register both providers
-      service.registerProvider(firstProvider)
-      service.registerProvider(secondProvider)
-      
-      // Execute
-      await service.fetchRatesForDate(TEST_DATE, TEST_SCOPE)
-      
-      // Assert - both providers should be called
-      expect(firstProvider.fetchRates).toHaveBeenCalled()
-      expect(secondProvider.fetchRates).toHaveBeenCalled()
-    })
-
-    it('supports registering many providers', async () => {
-      // Setup
-      const currencies = [
-        createTestCurrency({ code: 'USD' }),
-        createTestCurrency({ code: 'EUR' }),
-        createTestCurrency({ code: 'GBP' }),
-      ]
-      
-      const { em } = createMockEntityManager({ currencies })
-      service = new RateFetchingService(em)
-      
-      const provider1 = createMockProvider({
-        source: 'P1',
-        rates: [createTestRate({ fromCurrencyCode: 'USD', toCurrencyCode: 'EUR' })],
-      })
-      
-      const provider2 = createMockProvider({
-        source: 'P2',
-        rates: [createTestRate({ fromCurrencyCode: 'EUR', toCurrencyCode: 'GBP' })],
-      })
-      
-      const provider3 = createMockProvider({
-        source: 'P3',
-        rates: [createTestRate({ fromCurrencyCode: 'GBP', toCurrencyCode: 'USD' })],
-      })
-      
-      service.registerProvider(provider1)
-      service.registerProvider(provider2)
-      service.registerProvider(provider3)
-      
-      // Execute
-      const result = await service.fetchRatesForDate(TEST_DATE, TEST_SCOPE)
-      
-      // Assert - all three providers should be called
-      expect(provider1.fetchRates).toHaveBeenCalled()
-      expect(provider2.fetchRates).toHaveBeenCalled()
-      expect(provider3.fetchRates).toHaveBeenCalled()
-      expect(result.totalFetched).toBe(3)
-    })
-  })
-})

package/src/modules/currencies/services/__tests__/rateFetchingService.setup.ts

@@ -1,188 +0,0 @@
-import type { EntityManager } from '@mikro-orm/core'
-import { Currency, ExchangeRate } from '../../data/entities'
-import type { RateProvider, RateProviderResult } from '../providers/base'
-
-export interface MockEntityManagerConfig {
-  currencies?: Currency[]
-  existingRates?: ExchangeRate[]
-  shouldFailTransaction?: boolean
-}
-
-export interface MockProviderConfig {
-  source: string
-  name?: string
-  isAvailable?: boolean
-  rates?: RateProviderResult[]
-  error?: Error
-}
-
-/**
- * Create a mock EntityManager for testing
- */
-export function createMockEntityManager(config: MockEntityManagerConfig = {}) {
-  const persisted: any[] = []
-  const flushed: boolean[] = []
-  
-  const mockEm: any = {
-    find: jest.fn(async (entityClass: any, filter: any) => {
-      // Return currencies for Currency entity queries
-      if (entityClass === Currency || entityClass.name === 'Currency') {
-        const currencies = config.currencies || []
-        // Apply filters if specified
-        return currencies.filter(c => {
-          if (filter.isActive !== undefined && c.isActive !== filter.isActive) return false
-          if (filter.deletedAt !== undefined && filter.deletedAt === null && c.deletedAt !== null) return false
-          if (filter.tenantId && c.tenantId !== filter.tenantId) return false
-          if (filter.organizationId && c.organizationId !== filter.organizationId) return false
-          return true
-        })
-      }
-      
-      // Return exchange rates for ExchangeRate entity queries
-      if (entityClass === ExchangeRate || entityClass.name === 'ExchangeRate') {
-        const rates = config.existingRates || []
-        // Apply filters if specified
-        return rates.filter(r => {
-          if (filter.organizationId && r.organizationId !== filter.organizationId) return false
-          if (filter.tenantId && r.tenantId !== filter.tenantId) return false
-          if (filter.fromCurrencyCode && r.fromCurrencyCode !== filter.fromCurrencyCode) return false
-          if (filter.toCurrencyCode && r.toCurrencyCode !== filter.toCurrencyCode) return false
-          if (filter.date && r.date.getTime() !== filter.date.getTime()) return false
-          if (filter.isActive !== undefined && r.isActive !== filter.isActive) return false
-          if (filter.deletedAt !== undefined && filter.deletedAt === null && r.deletedAt !== null) return false
-          return true
-        })
-      }
-      
-      return []
-    }),
-    
-    findOne: jest.fn(async (entityClass: any, filter: any) => {
-      // Return existing rate if it matches all unique constraint fields
-      if ((entityClass === ExchangeRate || entityClass.name === 'ExchangeRate') && config.existingRates) {
-        return config.existingRates.find(r =>
-          r.organizationId === filter.organizationId &&
-          r.tenantId === filter.tenantId &&
-          r.fromCurrencyCode === filter.fromCurrencyCode &&
-          r.toCurrencyCode === filter.toCurrencyCode &&
-          r.date.getTime() === filter.date.getTime() &&
-          r.source === filter.source
-        ) || null
-      }
-      return null
-    }),
-    
-    create: jest.fn((entityClass: any, data: any) => ({
-      ...data,
-      id: `mock-id-${Math.random()}`,
-    })),
-    
-    persist: jest.fn((entity: any) => {
-      persisted.push(entity)
-    }),
-    
-    flush: jest.fn(async () => {
-      flushed.push(true)
-    }),
-    
-    transactional: jest.fn(async (callback: (em: any) => Promise<any>) => {
-      if (config.shouldFailTransaction) {
-        throw new Error('Transaction failed')
-      }
-      // Create a separate mock EM for the transaction with same config
-      const txEm = createMockEntityManager(config).em
-      return callback(txEm)
-    }),
-  }
-  
-  return {
-    em: mockEm,
-    persisted,
-    flushed,
-  }
-}
-
-/**
- * Create a mock RateProvider for testing
- */
-export function createMockProvider(config: MockProviderConfig): RateProvider {
-  return {
-    source: config.source,
-    name: config.name || config.source,
-    isAvailable: jest.fn(() => config.isAvailable ?? true),
-    fetchRates: jest.fn(async (date, scope, currencies) => {
-      if (config.error) {
-        throw config.error
-      }
-      return config.rates || []
-    }),
-  }
-}
-
-/**
- * Create a test Currency entity
- */
-export function createTestCurrency(overrides?: Partial<Currency>): Currency {
-  return {
-    id: overrides?.id || `currency-${Math.random()}`,
-    organizationId: 'test-org',
-    tenantId: 'test-tenant',
-    code: 'USD',
-    name: 'US Dollar',
-    symbol: '$',
-    decimalPlaces: 2,
-    thousandsSeparator: ',',
-    decimalSeparator: '.',
-    isBase: false,
-    isActive: true,
-    createdAt: new Date('2024-01-01'),
-    updatedAt: new Date('2024-01-01'),
-    deletedAt: null,
-    ...overrides,
-  } as Currency
-}
-
-/**
- * Create a test RateProviderResult
- */
-export function createTestRate(overrides?: Partial<RateProviderResult>): RateProviderResult {
-  return {
-    fromCurrencyCode: 'USD',
-    toCurrencyCode: 'EUR',
-    rate: '0.85',
-    source: 'TEST',
-    date: new Date('2024-01-15T00:00:00.000Z'),
-    ...overrides,
-  }
-}
-
-/**
- * Create a test ExchangeRate entity
- */
-export function createTestExchangeRate(overrides?: Partial<ExchangeRate>): ExchangeRate {
-  return {
-    id: `rate-${Math.random()}`,
-    organizationId: 'test-org',
-    tenantId: 'test-tenant',
-    fromCurrencyCode: 'USD',
-    toCurrencyCode: 'EUR',
-    rate: '0.85',
-    date: new Date('2024-01-15T00:00:00.000Z'),
-    source: 'TEST',
-    isActive: true,
-    createdAt: new Date('2024-01-01'),
-    updatedAt: new Date('2024-01-01'),
-    deletedAt: null,
-    ...overrides,
-  } as ExchangeRate
-}
-
-/**
- * Common test constants
- */
-export const TEST_SCOPE = {
-  tenantId: 'test-tenant',
-  organizationId: 'test-org',
-}
-
-export const TEST_DATE = new Date('2024-01-15T00:00:00.000Z')

package/src/modules/customers/__integration__/TC-CRM-001.spec.ts

@@ -1,42 +0,0 @@
-import { test, expect } from '@playwright/test';
-import { login } from '@open-mercato/core/modules/core/__integration__/helpers/auth';
-import { getAuthToken } from '@open-mercato/core/modules/core/__integration__/helpers/api';
-import { deleteEntityIfExists } from '@open-mercato/core/modules/core/__integration__/helpers/crmFixtures';
-
-/**
- * TC-CRM-001: Company Creation
- * Source: .ai/qa/scenarios/TC-CRM-001-company-creation.md
- */
-test.describe('TC-CRM-001: Company Creation', () => {
-  test('should create a company from create form and show it in companies list', async ({ page, request }) => {
-    let token: string | null = null;
-    let companyId: string | null = null;
-    const companyName = `QA TC-CRM-001 ${Date.now()}`;
-
-    try {
-      token = await getAuthToken(request);
-
-      await login(page, 'admin');
-      await page.goto('/backend/customers/companies');
-
-      await page.getByRole('link', { name: /Create Company/i }).first().click();
-      await page.locator('form').getByRole('textbox').first().fill(companyName);
-      await page.getByPlaceholder('https://example.com').fill('https://example.com');
-      await page.locator('form').getByRole('button', { name: /Create Company/i }).click();
-
-      await expect(page).toHaveURL(/\/backend\/customers\/companies\/[0-9a-f-]{36}$/i);
-      await expect(page.getByRole('button', { name: companyName, exact: true }).first()).toBeVisible();
-
-      const url = page.url();
-      const idMatch = url.match(/\/backend\/customers\/companies\/([0-9a-f-]{36})$/i);
-      companyId = idMatch ? idMatch[1] : null;
-      expect(companyId, 'Expected created company id in detail URL').toBeTruthy();
-
-      await page.goto('/backend/customers/companies');
-      await page.getByRole('textbox', { name: /Search companies/i }).fill(companyName);
-      await expect(page.getByRole('link', { name: companyName, exact: true })).toBeVisible();
-    } finally {
-      await deleteEntityIfExists(request, token, '/api/customers/companies', companyId);
-    }
-  });
-});

package/src/modules/customers/__integration__/TC-CRM-002.spec.ts

@@ -1,47 +0,0 @@
-import { expect, test } from '@playwright/test';
-import { login } from '@open-mercato/core/modules/core/__integration__/helpers/auth';
-import { deleteEntityIfExists } from '@open-mercato/core/modules/core/__integration__/helpers/crmFixtures';
-import { getAuthToken } from '@open-mercato/core/modules/core/__integration__/helpers/api';
-
-/**
- * TC-CRM-002: Company Creation Validation Errors
- * Source: .ai/qa/scenarios/TC-CRM-002-company-creation-validation.md
- */
-test.describe('TC-CRM-002: Company Creation Validation Errors', () => {
-  test('should block invalid input, show field errors, then allow create after correction', async ({ page, request }) => {
-    let token: string | null = null;
-    let companyId: string | null = null;
-    const companyName = `QA TC-CRM-002 ${Date.now()}`;
-
-    try {
-      token = await getAuthToken(request);
-
-      await login(page, 'admin');
-      await page.goto('/backend/customers/companies/create');
-
-      await page.getByRole('button', { name: 'Create Company' }).first().click();
-      await expect(page.getByText('This field is required')).toBeVisible();
-
-      await page.locator('form').getByRole('textbox').first().fill(companyName);
-      await page.getByPlaceholder('name@example.com').fill('invalid-email');
-      await page.getByPlaceholder('https://example.com').fill('notaurl');
-      await page.getByRole('button', { name: 'Create Company' }).first().click();
-
-      await expect(page.getByText('Invalid email address')).toBeVisible();
-      await expect(page.getByText('Invalid URL')).toBeVisible();
-
-      await page.getByPlaceholder('name@example.com').fill('qa+crm002@example.com');
-      await page.getByPlaceholder('https://example.com').fill('https://example.com');
-      await page.getByRole('button', { name: 'Create Company' }).first().click();
-
-      await expect(page).toHaveURL(/\/backend\/customers\/companies\/[0-9a-f-]{36}$/i);
-      await expect(page.getByRole('button', { name: companyName, exact: true }).first()).toBeVisible();
-
-      const idMatch = page.url().match(/\/backend\/customers\/companies\/([0-9a-f-]{36})$/i);
-      companyId = idMatch?.[1] ?? null;
-      expect(companyId, 'Expected created company id in detail URL').toBeTruthy();
-    } finally {
-      await deleteEntityIfExists(request, token, '/api/customers/companies', companyId);
-    }
-  });
-});

package/src/modules/customers/__integration__/TC-CRM-003.spec.ts

@@ -1,55 +0,0 @@
-import { expect, test } from '@playwright/test';
-import { login } from '@open-mercato/core/modules/core/__integration__/helpers/auth';
-import { createCompanyFixture, deleteEntityIfExists } from '@open-mercato/core/modules/core/__integration__/helpers/crmFixtures';
-import { getAuthToken } from '@open-mercato/core/modules/core/__integration__/helpers/api';
-
-function escapeRegex(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
-/**
- * TC-CRM-003: Edit Company Details
- * Source: .ai/qa/scenarios/TC-CRM-003-company-edit.md
- */
-test.describe('TC-CRM-003: Edit Company Details', () => {
-  test('should update company fields from detail page and persist changes in list view', async ({ page, request }) => {
-    let token: string | null = null;
-    let companyId: string | null = null;
-    const originalName = `QA TC-CRM-003 Original ${Date.now()}`;
-    const updatedName = `QA TC-CRM-003 Updated ${Date.now()}`;
-    const updatedWebsite = `https://crm003-${Date.now()}.example.com`;
-
-    try {
-      token = await getAuthToken(request);
-      companyId = await createCompanyFixture(request, token, originalName);
-
-      await login(page, 'admin');
-      await page.goto(`/backend/customers/companies/${companyId}`);
-
-      await page.getByRole('button', { name: new RegExp(`Display name\\s+${escapeRegex(originalName)}`) }).click();
-      await page.getByRole('textbox', { name: 'Enter company name' }).fill(updatedName);
-      await page.getByRole('button', { name: /Save .*Ctrl\+Enter/i }).first().click();
-      await expect(page.getByRole('button', { name: new RegExp(`Display name\\s+${escapeRegex(updatedName)}`) })).toBeVisible();
-
-      await page.getByRole('button', { name: /Website/i }).click();
-      await page.getByPlaceholder('https://example.com').fill(updatedWebsite);
-      await page.getByRole('button', { name: /Save .*Ctrl\+Enter/i }).first().click();
-      await expect(page.getByRole('button', { name: new RegExp(`Website\\s+${escapeRegex(updatedWebsite)}`) })).toBeVisible();
-
-      await page.getByRole('button', { name: /Lifecycle stage/i }).click();
-      await page
-        .locator('select')
-        .filter({ has: page.locator('option', { hasText: 'Prospect' }) })
-        .first()
-        .selectOption({ label: 'Prospect' });
-      await page.getByRole('button', { name: /Save .*Ctrl\+Enter/i }).first().click();
-      await expect(page.getByRole('button', { name: /Lifecycle stage\s+Prospect/i })).toBeVisible();
-
-      await page.goto('/backend/customers/companies');
-      await page.getByRole('textbox', { name: /Search companies/i }).fill(updatedName);
-      await expect(page.getByRole('link', { name: updatedName, exact: true })).toBeVisible();
-    } finally {
-      await deleteEntityIfExists(request, token, '/api/customers/companies', companyId);
-    }
-  });
-});