adserver-dashboard 1.0.0

package/client/src/lib/__tests__/accessibility.test.ts

@@ -0,0 +1,104 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { 
+  focusableSelector, 
+  announce, 
+  generateId, 
+  visuallyHiddenStyles 
+} from '../accessibility';
+
+describe('accessibility', () => {
+  describe('focusableSelector', () => {
+    it('should include all focusable element selectors', () => {
+      expect(focusableSelector).toContain('button');
+      expect(focusableSelector).toContain('[href]');
+      expect(focusableSelector).toContain('input');
+      expect(focusableSelector).toContain('select');
+      expect(focusableSelector).toContain('textarea');
+      expect(focusableSelector).toContain('[tabindex]:not([tabindex="-1"])');
+    });
+  });
+
+  describe('announce', () => {
+    beforeEach(() => {
+      vi.useFakeTimers();
+    });
+
+    afterEach(() => {
+      vi.useRealTimers();
+    });
+
+    it('should create an element with aria-live polite by default', () => {
+      const appendChildSpy = vi.spyOn(document.body, 'appendChild');
+      
+      announce('Test message');
+      
+      expect(appendChildSpy).toHaveBeenCalled();
+      const el = appendChildSpy.mock.calls[0][0] as HTMLElement;
+      expect(el.getAttribute('aria-live')).toBe('polite');
+      expect(el.getAttribute('aria-atomic')).toBe('true');
+      expect(el.textContent).toBe('Test message');
+      
+      appendChildSpy.mockRestore();
+    });
+
+    it('should create an element with aria-live assertive when specified', () => {
+      const appendChildSpy = vi.spyOn(document.body, 'appendChild');
+      
+      announce('Urgent message', 'assertive');
+      
+      expect(appendChildSpy).toHaveBeenCalled();
+      const el = appendChildSpy.mock.calls[0][0] as HTMLElement;
+      expect(el.getAttribute('aria-live')).toBe('assertive');
+      
+      appendChildSpy.mockRestore();
+    });
+
+    it('should remove the element after 1 second', () => {
+      const appendChildSpy = vi.spyOn(document.body, 'appendChild');
+      const removeChildSpy = vi.spyOn(document.body, 'removeChild');
+      
+      announce('Test message');
+      
+      expect(removeChildSpy).not.toHaveBeenCalled();
+      
+      vi.advanceTimersByTime(1000);
+      
+      expect(removeChildSpy).toHaveBeenCalled();
+      
+      appendChildSpy.mockRestore();
+      removeChildSpy.mockRestore();
+    });
+  });
+
+  describe('generateId', () => {
+    it('should generate an id with default prefix', () => {
+      const id = generateId();
+      expect(id).toMatch(/^mw-[a-z0-9]{9}$/);
+    });
+
+    it('should generate an id with custom prefix', () => {
+      const id = generateId('custom');
+      expect(id).toMatch(/^custom-[a-z0-9]{9}$/);
+    });
+
+    it('should generate unique ids', () => {
+      const id1 = generateId();
+      const id2 = generateId();
+      expect(id1).not.toBe(id2);
+    });
+  });
+
+  describe('visuallyHiddenStyles', () => {
+    it('should have correct visually hidden properties', () => {
+      expect(visuallyHiddenStyles.position).toBe('absolute');
+      expect(visuallyHiddenStyles.width).toBe('1px');
+      expect(visuallyHiddenStyles.height).toBe('1px');
+      expect(visuallyHiddenStyles.padding).toBe('0');
+      expect(visuallyHiddenStyles.margin).toBe('-1px');
+      expect(visuallyHiddenStyles.overflow).toBe('hidden');
+      expect(visuallyHiddenStyles.clip).toBe('rect(0, 0, 0, 0)');
+      expect(visuallyHiddenStyles.whiteSpace).toBe('nowrap');
+      expect(visuallyHiddenStyles.borderWidth).toBe('0');
+    });
+  });
+});

package/client/src/lib/__tests__/date-utils.test.ts

@@ -0,0 +1,199 @@
+import { describe, it, expect } from 'vitest';
+import {
+  toAPIDateString,
+  fromAPIDateString,
+  formatDate,
+  isSameDay,
+  isDateBetween,
+  toAPIDateRange,
+  getTodayDate,
+  getTodayDateString,
+} from '../date-utils';
+
+describe('date-utils', () => {
+  describe('toAPIDateString', () => {
+    it('should convert a date to YYYY-MM-DD format', () => {
+      const date = new Date(2024, 0, 15);
+      expect(toAPIDateString(date)).toBe('2024-01-15');
+    });
+
+    it('should pad single digit months and days', () => {
+      const date = new Date(2024, 0, 5);
+      expect(toAPIDateString(date)).toBe('2024-01-05');
+    });
+
+    it('should handle December correctly', () => {
+      const date = new Date(2024, 11, 31);
+      expect(toAPIDateString(date)).toBe('2024-12-31');
+    });
+
+    it('should throw error for null date', () => {
+      expect(() => toAPIDateString(null)).toThrow('Invalid date provided');
+    });
+
+    it('should throw error for invalid date', () => {
+      expect(() => toAPIDateString('not a date' as unknown as Date)).toThrow('Invalid date provided');
+    });
+  });
+
+  describe('fromAPIDateString', () => {
+    it('should convert YYYY-MM-DD string to Date', () => {
+      const result = fromAPIDateString('2024-01-15');
+      expect(result.getFullYear()).toBe(2024);
+      expect(result.getMonth()).toBe(0);
+      expect(result.getDate()).toBe(15);
+    });
+
+    it('should handle December correctly', () => {
+      const result = fromAPIDateString('2024-12-31');
+      expect(result.getFullYear()).toBe(2024);
+      expect(result.getMonth()).toBe(11);
+      expect(result.getDate()).toBe(31);
+    });
+
+    it('should throw error for null string', () => {
+      expect(() => fromAPIDateString(null as unknown as string)).toThrow('Invalid date string provided');
+    });
+
+    it('should throw error for invalid format', () => {
+      expect(() => fromAPIDateString('invalid')).toThrow('Invalid date string format');
+    });
+
+    it('should throw error for empty string', () => {
+      expect(() => fromAPIDateString('')).toThrow('Invalid date string provided');
+    });
+  });
+
+  describe('formatDate', () => {
+    it('should format date as dd/MM/yyyy by default', () => {
+      const date = new Date(2024, 0, 15);
+      expect(formatDate(date)).toBe('15/01/2024');
+    });
+
+    it('should format date as MM/dd/yyyy when specified', () => {
+      const date = new Date(2024, 0, 15);
+      expect(formatDate(date, 'MM/dd/yyyy')).toBe('01/15/2024');
+    });
+
+    it('should return empty string for null date', () => {
+      expect(formatDate(null)).toBe('');
+    });
+
+    it('should return empty string for invalid date', () => {
+      expect(formatDate('invalid' as unknown as Date)).toBe('');
+    });
+  });
+
+  describe('isSameDay', () => {
+    it('should return true for same dates', () => {
+      const date1 = new Date(2024, 0, 15);
+      const date2 = new Date(2024, 0, 15);
+      expect(isSameDay(date1, date2)).toBe(true);
+    });
+
+    it('should return true for same day with different times', () => {
+      const date1 = new Date(2024, 0, 15, 10, 30);
+      const date2 = new Date(2024, 0, 15, 18, 45);
+      expect(isSameDay(date1, date2)).toBe(true);
+    });
+
+    it('should return false for different days', () => {
+      const date1 = new Date(2024, 0, 15);
+      const date2 = new Date(2024, 0, 16);
+      expect(isSameDay(date1, date2)).toBe(false);
+    });
+
+    it('should return false if first date is null', () => {
+      expect(isSameDay(null, new Date())).toBe(false);
+    });
+
+    it('should return false if second date is null', () => {
+      expect(isSameDay(new Date(), null)).toBe(false);
+    });
+
+    it('should return false if both dates are null', () => {
+      expect(isSameDay(null, null)).toBe(false);
+    });
+  });
+
+  describe('isDateBetween', () => {
+    it('should return true for date between start and end', () => {
+      const date = new Date(2024, 0, 15);
+      const start = new Date(2024, 0, 10);
+      const end = new Date(2024, 0, 20);
+      expect(isDateBetween(date, start, end)).toBe(true);
+    });
+
+    it('should return false for date equal to start', () => {
+      const date = new Date(2024, 0, 10);
+      const start = new Date(2024, 0, 10);
+      const end = new Date(2024, 0, 20);
+      expect(isDateBetween(date, start, end)).toBe(false);
+    });
+
+    it('should return false for date equal to end', () => {
+      const date = new Date(2024, 0, 20);
+      const start = new Date(2024, 0, 10);
+      const end = new Date(2024, 0, 20);
+      expect(isDateBetween(date, start, end)).toBe(false);
+    });
+
+    it('should return false for date before range', () => {
+      const date = new Date(2024, 0, 5);
+      const start = new Date(2024, 0, 10);
+      const end = new Date(2024, 0, 20);
+      expect(isDateBetween(date, start, end)).toBe(false);
+    });
+
+    it('should return false for date after range', () => {
+      const date = new Date(2024, 0, 25);
+      const start = new Date(2024, 0, 10);
+      const end = new Date(2024, 0, 20);
+      expect(isDateBetween(date, start, end)).toBe(false);
+    });
+
+    it('should return false if start is null', () => {
+      const date = new Date(2024, 0, 15);
+      expect(isDateBetween(date, null, new Date())).toBe(false);
+    });
+
+    it('should return false if end is null', () => {
+      const date = new Date(2024, 0, 15);
+      expect(isDateBetween(date, new Date(), null)).toBe(false);
+    });
+  });
+
+  describe('toAPIDateRange', () => {
+    it('should convert date range to API format', () => {
+      const from = new Date(2024, 0, 1);
+      const to = new Date(2024, 0, 31);
+      const result = toAPIDateRange(from, to);
+      expect(result).toEqual({
+        start_date: '2024-01-01',
+        end_date: '2024-01-31',
+      });
+    });
+  });
+
+  describe('getTodayDate', () => {
+    it('should return today at midnight', () => {
+      const result = getTodayDate();
+      const now = new Date();
+      expect(result.getFullYear()).toBe(now.getFullYear());
+      expect(result.getMonth()).toBe(now.getMonth());
+      expect(result.getDate()).toBe(now.getDate());
+      expect(result.getHours()).toBe(0);
+      expect(result.getMinutes()).toBe(0);
+      expect(result.getSeconds()).toBe(0);
+    });
+  });
+
+  describe('getTodayDateString', () => {
+    it('should return today in YYYY-MM-DD format', () => {
+      const result = getTodayDateString();
+      const now = new Date();
+      const expected = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}`;
+      expect(result).toBe(expected);
+    });
+  });
+});

package/client/src/lib/__tests__/dsp-buyer-api.test.ts

@@ -0,0 +1,127 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { listDspBuyers, getDspDropdownList } from '@/lib/dsp-buyer-api';
+import { directCampaignAuth } from '@/lib/auth-service';
+
+vi.mock('@/lib/auth-service', () => ({
+  directCampaignAuth: {
+    fetch: vi.fn(),
+  },
+}));
+
+const mockFetch = directCampaignAuth.fetch as ReturnType<typeof vi.fn>;
+
+function mockResponse(body: any) {
+  const text = typeof body === 'string' ? body : JSON.stringify(body);
+  mockFetch.mockResolvedValue({
+    ok: true,
+    text: async () => text,
+  });
+}
+
+describe('listDspBuyers', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('calls the correct URL with default params', async () => {
+    mockResponse([]);
+    await listDspBuyers();
+    const calledUrl = mockFetch.mock.calls[0][0] as string;
+    expect(calledUrl).toContain('/dsp-buyer?');
+    expect(calledUrl).toContain('page=0');
+    expect(calledUrl).toContain('size=10');
+    expect(calledUrl).toContain('sort=lastModifiedDate%2Cdesc');
+  });
+
+  it('passes name parameter when provided', async () => {
+    mockResponse([]);
+    await listDspBuyers({ name: 'TestDSP' });
+    const calledUrl = mockFetch.mock.calls[0][0] as string;
+    expect(calledUrl).toContain('name=TestDSP');
+  });
+
+  it('passes searchText parameter when provided', async () => {
+    mockResponse([]);
+    await listDspBuyers({ searchText: 'search term' });
+    const calledUrl = mockFetch.mock.calls[0][0] as string;
+    expect(calledUrl).toContain('searchText=search+term');
+  });
+
+  it('passes custom size and page params', async () => {
+    mockResponse([]);
+    await listDspBuyers({ size: 50, page: 3 });
+    const calledUrl = mockFetch.mock.calls[0][0] as string;
+    expect(calledUrl).toContain('page=3');
+    expect(calledUrl).toContain('size=50');
+  });
+
+  it('handles direct array response', async () => {
+    const buyers = [{ id: '1', name: 'Buyer1' }, { id: '2', name: 'Buyer2' }];
+    mockResponse(buyers);
+    const result = await listDspBuyers();
+    expect(result).toEqual(buyers);
+  });
+
+  it('handles paginated content response', async () => {
+    const buyers = [{ id: '1', name: 'Buyer1' }];
+    mockResponse({ content: buyers, totalElements: 1 });
+    const result = await listDspBuyers();
+    expect(result).toEqual(buyers);
+  });
+
+  it('returns empty array for non-array/non-paginated response', async () => {
+    mockResponse({ someField: 'value' });
+    const result = await listDspBuyers();
+    expect(result).toEqual([]);
+  });
+
+  it('returns empty array when API returns empty text', async () => {
+    mockFetch.mockResolvedValue({
+      ok: true,
+      text: async () => '',
+    });
+    const result = await listDspBuyers();
+    expect(result).toEqual([]);
+  });
+});
+
+describe('getDspDropdownList', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('calls the correct master API URL with module=DSP', async () => {
+    mockResponse([]);
+    await getDspDropdownList();
+    const calledUrl = mockFetch.mock.calls[0][0] as string;
+    expect(calledUrl).toContain('/master/api/v2/rest/dropdown');
+    expect(calledUrl).toContain('module=DSP');
+  });
+
+  it('handles direct array response', async () => {
+    const items = [{ id: '1', name: 'DSP1' }, { id: '2', name: 'DSP2' }];
+    mockResponse(items);
+    const result = await getDspDropdownList();
+    expect(result).toEqual(items);
+  });
+
+  it('handles content response', async () => {
+    const items = [{ id: '1', name: 'DSP1' }];
+    mockResponse({ content: items });
+    const result = await getDspDropdownList();
+    expect(result).toEqual(items);
+  });
+
+  it('handles data response', async () => {
+    const items = [{ id: '1', name: 'DSP1' }];
+    mockResponse({ data: items });
+    const result = await getDspDropdownList();
+    expect(result).toEqual(items);
+  });
+
+  it('returns empty array for unexpected response shape', async () => {
+    mockResponse({ unexpected: 'value' });
+    const result = await getDspDropdownList();
+    expect(result).toEqual([]);
+  });
+});

package/client/src/lib/__tests__/dsp-buyer-integration.test.ts

@@ -0,0 +1,247 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import type { DspBuyer, DspDropdownItem } from '@/lib/dsp-buyer-api';
+
+interface BuyerEntry {
+  dsp: string;
+  seatId: string;
+  buyerName: string;
+  buyerId?: string;
+}
+
+function getBuyersForDsp(
+  allBuyers: DspBuyer[],
+  dspValue: string,
+  dspOptions: DspDropdownItem[]
+): DspBuyer[] {
+  if (!dspValue) return allBuyers;
+  const byDspId = allBuyers.filter((b) => b.dspId === dspValue);
+  if (byDspId.length > 0) return byDspId;
+  const dsp = dspOptions.find((d) => d.id === dspValue);
+  if (!dsp) return allBuyers;
+  return allBuyers.filter((b) => b.dsp === dsp.name);
+}
+
+function handleBuyerSelect(
+  buyers: BuyerEntry[],
+  index: number,
+  buyerValue: string,
+  buyersForDsp: DspBuyer[]
+): BuyerEntry[] {
+  const selectedBuyerData = buyersForDsp.find((b) => b.id === buyerValue);
+  if (selectedBuyerData) {
+    const newBuyers = [...buyers];
+    newBuyers[index] = {
+      ...newBuyers[index],
+      buyerId: selectedBuyerData.id,
+      buyerName: selectedBuyerData.seatName || selectedBuyerData.name,
+      seatId: selectedBuyerData.seatId || '',
+    };
+    return newBuyers;
+  }
+  return buyers;
+}
+
+function updateBuyer(
+  buyers: BuyerEntry[],
+  index: number,
+  field: string,
+  value: string
+): BuyerEntry[] {
+  const newBuyers = [...buyers];
+  if (field === 'dsp') {
+    newBuyers[index] = { ...newBuyers[index], dsp: value, buyerName: '', seatId: '', buyerId: undefined };
+  } else {
+    newBuyers[index] = { ...newBuyers[index], [field]: value };
+  }
+  return newBuyers;
+}
+
+function mapBuyersForEditMode(
+  existingBuyers: BuyerEntry[],
+  dspOptions: DspDropdownItem[],
+  availableBuyers: DspBuyer[]
+): BuyerEntry[] {
+  return existingBuyers.map((b) => {
+    let mapped = { ...b };
+    if (b.dsp && dspOptions.length > 0) {
+      const matchById = dspOptions.find((d) => d.id === b.dsp);
+      if (!matchById) {
+        const matchByName = dspOptions.find((d) => d.name.toLowerCase() === b.dsp.toLowerCase());
+        if (matchByName) {
+          mapped.dsp = matchByName.id;
+        }
+      }
+    }
+    if (!mapped.buyerId && availableBuyers.length > 0 && mapped.buyerName) {
+      const matchedBuyer = availableBuyers.find(
+        (ab) => (ab.seatName || ab.name) === mapped.buyerName ||
+          (mapped.seatId && ab.seatId === mapped.seatId)
+      );
+      if (matchedBuyer) {
+        mapped.buyerId = matchedBuyer.id;
+      }
+    }
+    return mapped;
+  });
+}
+
+const makeBuyer = (overrides: Partial<DspBuyer> = {}): DspBuyer => ({
+  createdDate: '2024-01-01',
+  lastModifiedDate: '2024-01-01',
+  id: 'buyer-1',
+  dspId: 'dsp-1',
+  dsp: 'Test DSP',
+  name: 'Buyer One',
+  ip: '127.0.0.1',
+  country: 'US',
+  buyerAccountId: null,
+  seatId: 'seat-1',
+  seatName: 'Seat One',
+  emailAddress: 'buyer@test.com',
+  ...overrides,
+});
+
+describe('getBuyersForDsp', () => {
+  const dspOptions: DspDropdownItem[] = [
+    { id: 'dsp-1', name: 'Alpha DSP' },
+    { id: 'dsp-2', name: 'Beta DSP' },
+  ];
+
+  const allBuyers: DspBuyer[] = [
+    makeBuyer({ id: 'b1', dspId: 'dsp-1', dsp: 'Alpha DSP', name: 'Buyer A' }),
+    makeBuyer({ id: 'b2', dspId: 'dsp-2', dsp: 'Beta DSP', name: 'Buyer B' }),
+    makeBuyer({ id: 'b3', dspId: 'dsp-1', dsp: 'Alpha DSP', name: 'Buyer C' }),
+  ];
+
+  it('returns all buyers when dspValue is empty', () => {
+    expect(getBuyersForDsp(allBuyers, '', dspOptions)).toEqual(allBuyers);
+  });
+
+  it('filters buyers by dspId', () => {
+    const result = getBuyersForDsp(allBuyers, 'dsp-1', dspOptions);
+    expect(result).toHaveLength(2);
+    expect(result.every((b) => b.dspId === 'dsp-1')).toBe(true);
+  });
+
+  it('falls back to DSP name matching when dspId has no matches', () => {
+    const buyers = [
+      makeBuyer({ id: 'b1', dspId: 'old-id', dsp: 'Alpha DSP', name: 'Buyer A' }),
+    ];
+    const result = getBuyersForDsp(buyers, 'dsp-1', dspOptions);
+    expect(result).toHaveLength(1);
+    expect(result[0].dsp).toBe('Alpha DSP');
+  });
+
+  it('returns all buyers when no DSP found in dspOptions', () => {
+    const result = getBuyersForDsp(allBuyers, 'unknown-id', dspOptions);
+    expect(result).toEqual(allBuyers);
+  });
+});
+
+describe('handleBuyerSelect', () => {
+  const availableBuyers: DspBuyer[] = [
+    makeBuyer({ id: 'b1', seatName: 'Custom Seat', name: 'Buyer One', seatId: 'seat-100' }),
+    makeBuyer({ id: 'b2', seatName: '', name: 'Buyer Two', seatId: 'seat-200' }),
+  ];
+
+  let buyers: BuyerEntry[];
+
+  beforeEach(() => {
+    buyers = [{ dsp: 'dsp-1', seatId: '', buyerName: '' }];
+  });
+
+  it('sets buyerId, buyerName using seatName, and seatId from selected buyer', () => {
+    const result = handleBuyerSelect(buyers, 0, 'b1', availableBuyers);
+    expect(result[0].buyerId).toBe('b1');
+    expect(result[0].buyerName).toBe('Custom Seat');
+    expect(result[0].seatId).toBe('seat-100');
+  });
+
+  it('uses name when seatName is empty', () => {
+    const result = handleBuyerSelect(buyers, 0, 'b2', availableBuyers);
+    expect(result[0].buyerId).toBe('b2');
+    expect(result[0].buyerName).toBe('Buyer Two');
+    expect(result[0].seatId).toBe('seat-200');
+  });
+
+  it('returns unchanged buyers if buyer not found', () => {
+    const result = handleBuyerSelect(buyers, 0, 'nonexistent', availableBuyers);
+    expect(result).toBe(buyers);
+  });
+});
+
+describe('updateBuyer', () => {
+  let buyers: BuyerEntry[];
+
+  beforeEach(() => {
+    buyers = [{ dsp: 'dsp-1', seatId: 'seat-1', buyerName: 'Old Buyer', buyerId: 'b1' }];
+  });
+
+  it('clears buyerName, seatId, buyerId when field is dsp', () => {
+    const result = updateBuyer(buyers, 0, 'dsp', 'dsp-2');
+    expect(result[0].dsp).toBe('dsp-2');
+    expect(result[0].buyerName).toBe('');
+    expect(result[0].seatId).toBe('');
+    expect(result[0].buyerId).toBeUndefined();
+  });
+
+  it('only updates the specified field for non-dsp fields', () => {
+    const result = updateBuyer(buyers, 0, 'seatId', 'new-seat');
+    expect(result[0].seatId).toBe('new-seat');
+    expect(result[0].dsp).toBe('dsp-1');
+    expect(result[0].buyerName).toBe('Old Buyer');
+    expect(result[0].buyerId).toBe('b1');
+  });
+});
+
+describe('mapBuyersForEditMode', () => {
+  const dspOptions: DspDropdownItem[] = [
+    { id: 'dsp-id-1', name: 'Alpha DSP' },
+    { id: 'dsp-id-2', name: 'Beta DSP' },
+  ];
+
+  const availableBuyers: DspBuyer[] = [
+    makeBuyer({ id: 'resolved-b1', seatName: 'My Seat', name: 'Buyer One', seatId: 'seat-abc' }),
+  ];
+
+  it('maps DSP name to DSP id when id does not match any dspOptions', () => {
+    const existing: BuyerEntry[] = [
+      { dsp: 'Alpha DSP', seatId: '', buyerName: '' },
+    ];
+    const result = mapBuyersForEditMode(existing, dspOptions, []);
+    expect(result[0].dsp).toBe('dsp-id-1');
+  });
+
+  it('performs case-insensitive DSP name matching', () => {
+    const existing: BuyerEntry[] = [
+      { dsp: 'alpha dsp', seatId: '', buyerName: '' },
+    ];
+    const result = mapBuyersForEditMode(existing, dspOptions, []);
+    expect(result[0].dsp).toBe('dsp-id-1');
+  });
+
+  it('resolves buyerId by matching buyerName to seatName', () => {
+    const existing: BuyerEntry[] = [
+      { dsp: 'dsp-id-1', seatId: '', buyerName: 'My Seat' },
+    ];
+    const result = mapBuyersForEditMode(existing, dspOptions, availableBuyers);
+    expect(result[0].buyerId).toBe('resolved-b1');
+  });
+
+  it('resolves buyerId by matching seatId', () => {
+    const existing: BuyerEntry[] = [
+      { dsp: 'dsp-id-1', seatId: 'seat-abc', buyerName: 'Different Name' },
+    ];
+    const result = mapBuyersForEditMode(existing, dspOptions, availableBuyers);
+    expect(result[0].buyerId).toBe('resolved-b1');
+  });
+
+  it('leaves buyer unchanged when no mappings found', () => {
+    const existing: BuyerEntry[] = [
+      { dsp: 'unknown-dsp', seatId: 'unknown-seat', buyerName: 'Unknown Buyer' },
+    ];
+    const result = mapBuyersForEditMode(existing, dspOptions, availableBuyers);
+    expect(result[0].dsp).toBe('unknown-dsp');
+    expect(result[0].buyerId).toBeUndefined();
+  });
+});