adserver-dashboard 1.0.0

package/PCM/tests/seller-account-external-ids.test.js

@@ -0,0 +1,877 @@
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert';
+
+const BASE_URL = 'http://localhost:5000/api/v1/rest';
+
+async function request(method, path, body = null) {
+  const options = {
+    method,
+    headers: { 'Content-Type': 'application/json' }
+  };
+  if (body) options.body = JSON.stringify(body);
+  const res = await fetch(`${BASE_URL}${path}`, options);
+  const data = await res.json();
+  return { status: res.status, data };
+}
+
+function createDealPayload(overrides = {}) {
+  return {
+    name: `Test Deal ${Date.now()}`,
+    mode: 'DIRECT',
+    source: 'influence',
+    brand: 'Test Brand',
+    clientType: 'AGENCY',
+    currency: 'USD',
+    status: 'GENERATED',
+    marketSelection: { country: 'US', currency: 'USD' },
+    budgetSetup: { currency: 'USD', budgetAmount: 10000 },
+    campaignGoal: { type: 'IMPRESSIONS', targetValue: 1000000 },
+    ...overrides
+  };
+}
+
+describe('Seller/Account External IDs Test Suite', () => {
+  const createdDeals = [];
+
+  after(async () => {
+    for (const dealId of createdDeals) {
+      try {
+        await request('DELETE', `/deals/${dealId}`);
+      } catch (e) {
+      }
+    }
+  });
+
+  describe('1. Unit-Level Validation Tests', () => {
+    describe('1.1 Seller Schema - camelCase inputs', () => {
+      it('should accept seller with externalId in camelCase', async () => {
+        const payload = createDealPayload({
+          externalId: `seller-camel-ext-${Date.now()}`,
+          seller: {
+            id: 'SEL-001',
+            name: 'Test Seller',
+            externalId: 'seller-ext-camel-001'
+          }
+        });
+        const { status, data } = await request('POST', '/deals', payload);
+        assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+        createdDeals.push(data.result.dealId);
+      });
+
+      it('should accept seller with externalUserId in camelCase', async () => {
+        const payload = createDealPayload({
+          externalId: `seller-camel-user-${Date.now()}`,
+          seller: {
+            id: 'SEL-002',
+            name: 'Test Seller',
+            externalUserId: 'user-ext-camel-001'
+          }
+        });
+        const { status, data } = await request('POST', '/deals', payload);
+        assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+        createdDeals.push(data.result.dealId);
+      });
+
+      it('should accept seller with both externalId and externalUserId in camelCase', async () => {
+        const payload = createDealPayload({
+          externalId: `seller-camel-both-${Date.now()}`,
+          seller: {
+            id: 'SEL-003',
+            name: 'Test Seller',
+            externalId: 'seller-ext-001',
+            externalUserId: 'user-ext-001'
+          }
+        });
+        const { status, data } = await request('POST', '/deals', payload);
+        assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+        createdDeals.push(data.result.dealId);
+      });
+    });
+
+    describe('1.2 Seller Schema - snake_case inputs', () => {
+      it('should accept seller with external_id in snake_case', async () => {
+        const payload = createDealPayload({
+          externalId: `seller-snake-ext-${Date.now()}`,
+          seller: {
+            id: 'SEL-004',
+            name: 'Test Seller',
+            external_id: 'seller-ext-snake-001'
+          }
+        });
+        const { status, data } = await request('POST', '/deals', payload);
+        assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+        createdDeals.push(data.result.dealId);
+      });
+
+      it('should accept seller with external_user_id in snake_case', async () => {
+        const payload = createDealPayload({
+          externalId: `seller-snake-user-${Date.now()}`,
+          seller: {
+            id: 'SEL-005',
+            name: 'Test Seller',
+            external_user_id: 'user-ext-snake-001'
+          }
+        });
+        const { status, data } = await request('POST', '/deals', payload);
+        assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+        createdDeals.push(data.result.dealId);
+      });
+
+      it('should accept seller with both external_id and external_user_id in snake_case', async () => {
+        const payload = createDealPayload({
+          externalId: `seller-snake-both-${Date.now()}`,
+          seller: {
+            id: 'SEL-006',
+            name: 'Test Seller',
+            external_id: 'seller-ext-snake-002',
+            external_user_id: 'user-ext-snake-002'
+          }
+        });
+        const { status, data } = await request('POST', '/deals', payload);
+        assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+        createdDeals.push(data.result.dealId);
+      });
+    });
+
+    describe('1.3 Account Schema - camelCase inputs', () => {
+      it('should accept account with externalId in camelCase', async () => {
+        const payload = createDealPayload({
+          externalId: `account-camel-ext-${Date.now()}`,
+          account: {
+            userId: 'USR-001',
+            companyName: 'Test Company',
+            externalId: 'account-ext-camel-001'
+          }
+        });
+        const { status, data } = await request('POST', '/deals', payload);
+        assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+        createdDeals.push(data.result.dealId);
+      });
+
+      it('should accept account with externalUserId in camelCase', async () => {
+        const payload = createDealPayload({
+          externalId: `account-camel-user-${Date.now()}`,
+          account: {
+            userId: 'USR-002',
+            companyName: 'Test Company',
+            externalUserId: 'user-ext-camel-002'
+          }
+        });
+        const { status, data } = await request('POST', '/deals', payload);
+        assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+        createdDeals.push(data.result.dealId);
+      });
+
+      it('should accept account with both externalId and externalUserId in camelCase', async () => {
+        const payload = createDealPayload({
+          externalId: `account-camel-both-${Date.now()}`,
+          account: {
+            userId: 'USR-003',
+            companyName: 'Test Company',
+            externalId: 'account-ext-001',
+            externalUserId: 'user-ext-003'
+          }
+        });
+        const { status, data } = await request('POST', '/deals', payload);
+        assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+        createdDeals.push(data.result.dealId);
+      });
+    });
+
+    describe('1.4 Account Schema - snake_case inputs', () => {
+      it('should accept account with external_id in snake_case', async () => {
+        const payload = createDealPayload({
+          externalId: `account-snake-ext-${Date.now()}`,
+          account: {
+            user_id: 'USR-004',
+            company_name: 'Test Company',
+            external_id: 'account-ext-snake-001'
+          }
+        });
+        const { status, data } = await request('POST', '/deals', payload);
+        assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+        createdDeals.push(data.result.dealId);
+      });
+
+      it('should accept account with external_user_id in snake_case', async () => {
+        const payload = createDealPayload({
+          externalId: `account-snake-user-${Date.now()}`,
+          account: {
+            user_id: 'USR-005',
+            company_name: 'Test Company',
+            external_user_id: 'user-ext-snake-003'
+          }
+        });
+        const { status, data } = await request('POST', '/deals', payload);
+        assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+        createdDeals.push(data.result.dealId);
+      });
+
+      it('should accept account with both external_id and external_user_id in snake_case', async () => {
+        const payload = createDealPayload({
+          externalId: `account-snake-both-${Date.now()}`,
+          account: {
+            user_id: 'USR-006',
+            company_name: 'Test Company',
+            external_id: 'account-ext-snake-002',
+            external_user_id: 'user-ext-snake-004'
+          }
+        });
+        const { status, data } = await request('POST', '/deals', payload);
+        assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+        createdDeals.push(data.result.dealId);
+      });
+    });
+  });
+
+  describe('2. E2E Deal Creation & Retrieval Tests', () => {
+    describe('2.1 Full seller/account with external IDs - camelCase', () => {
+      let dealId;
+
+      it('should create deal with full seller/account objects (camelCase)', async () => {
+        const payload = createDealPayload({
+          externalId: `e2e-full-camel-${Date.now()}`,
+          seller: {
+            id: 'SEL-E2E-001',
+            name: 'E2E Seller',
+            publisherId: 'PUB-001',
+            publisherName: 'E2E Publisher',
+            phone: '+1234567890',
+            email: 'seller@test.com',
+            externalId: 'SEL-EXT-E2E-001',
+            externalUserId: 'USR-EXT-E2E-001'
+          },
+          account: {
+            userId: 'USR-E2E-001',
+            companyName: 'E2E Company',
+            companyId: 'COMP-001',
+            email: 'account@test.com',
+            externalId: 'ACC-EXT-E2E-001',
+            externalUserId: 'USR-EXT-E2E-002'
+          }
+        });
+        const { status, data } = await request('POST', '/deals', payload);
+        assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+        dealId = data.result.dealId;
+        createdDeals.push(dealId);
+      });
+
+      it('should retrieve deal with seller externalId/externalUserId in camelCase', async () => {
+        const { status, data } = await request('GET', `/deals/${dealId}`);
+        assert.strictEqual(status, 200);
+        assert.strictEqual(data.result.seller.externalId, 'SEL-EXT-E2E-001');
+        assert.strictEqual(data.result.seller.externalUserId, 'USR-EXT-E2E-001');
+      });
+
+      it('should retrieve deal with account externalId/externalUserId in camelCase', async () => {
+        const { status, data } = await request('GET', `/deals/${dealId}`);
+        assert.strictEqual(status, 200);
+        assert.strictEqual(data.result.account.externalId, 'ACC-EXT-E2E-001');
+        assert.strictEqual(data.result.account.externalUserId, 'USR-EXT-E2E-002');
+      });
+
+      it('should not have snake_case keys in response', async () => {
+        const { status, data } = await request('GET', `/deals/${dealId}`);
+        assert.strictEqual(status, 200);
+        assert.strictEqual(data.result.seller.external_id, undefined);
+        assert.strictEqual(data.result.seller.external_user_id, undefined);
+        assert.strictEqual(data.result.account.external_id, undefined);
+        assert.strictEqual(data.result.account.external_user_id, undefined);
+      });
+    });
+
+    describe('2.2 Full seller/account with external IDs - snake_case', () => {
+      let dealId;
+
+      it('should create deal with full seller/account objects (snake_case)', async () => {
+        const payload = createDealPayload({
+          externalId: `e2e-full-snake-${Date.now()}`,
+          seller: {
+            id: 'SEL-E2E-002',
+            name: 'E2E Seller Snake',
+            publisher_id: 'PUB-002',
+            publisher_name: 'E2E Publisher Snake',
+            phone: '+1234567891',
+            email: 'seller2@test.com',
+            external_id: 'SEL-EXT-SNAKE-001',
+            external_user_id: 'USR-EXT-SNAKE-001'
+          },
+          account: {
+            user_id: 'USR-E2E-002',
+            company_name: 'E2E Company Snake',
+            company_id: 'COMP-002',
+            email: 'account2@test.com',
+            external_id: 'ACC-EXT-SNAKE-001',
+            external_user_id: 'USR-EXT-SNAKE-002'
+          }
+        });
+        const { status, data } = await request('POST', '/deals', payload);
+        assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+        dealId = data.result.dealId;
+        createdDeals.push(dealId);
+      });
+
+      it('should retrieve deal with snake_case input converted to camelCase response', async () => {
+        const { status, data } = await request('GET', `/deals/${dealId}`);
+        assert.strictEqual(status, 200);
+        assert.strictEqual(data.result.seller.externalId, 'SEL-EXT-SNAKE-001');
+        assert.strictEqual(data.result.seller.externalUserId, 'USR-EXT-SNAKE-001');
+        assert.strictEqual(data.result.account.externalId, 'ACC-EXT-SNAKE-001');
+        assert.strictEqual(data.result.account.externalUserId, 'USR-EXT-SNAKE-002');
+      });
+
+      it('should convert publisherId/publisherName from snake_case to camelCase', async () => {
+        const { status, data } = await request('GET', `/deals/${dealId}`);
+        assert.strictEqual(status, 200);
+        assert.strictEqual(data.result.seller.publisherId, 'PUB-002');
+        assert.strictEqual(data.result.seller.publisherName, 'E2E Publisher Snake');
+      });
+
+      it('should convert account fields from snake_case to camelCase', async () => {
+        const { status, data } = await request('GET', `/deals/${dealId}`);
+        assert.strictEqual(status, 200);
+        assert.strictEqual(data.result.account.userId, 'USR-E2E-002');
+        assert.strictEqual(data.result.account.companyName, 'E2E Company Snake');
+        assert.strictEqual(data.result.account.companyId, 'COMP-002');
+      });
+    });
+  });
+
+  describe('3. Edge Case Tests', () => {
+    describe('3.1 Null values', () => {
+      let dealId;
+
+      it('should accept null externalId in seller', async () => {
+        const payload = createDealPayload({
+          externalId: `null-seller-ext-${Date.now()}`,
+          seller: {
+            id: 'SEL-NULL-001',
+            name: 'Null Test Seller',
+            externalId: null
+          }
+        });
+        const { status, data } = await request('POST', '/deals', payload);
+        assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+        dealId = data.result.dealId;
+        createdDeals.push(dealId);
+      });
+
+      it('should return null externalId when stored as null', async () => {
+        const { status, data } = await request('GET', `/deals/${dealId}`);
+        assert.strictEqual(status, 200);
+        assert.strictEqual(data.result.seller.externalId, null);
+      });
+
+      it('should accept null externalUserId in seller', async () => {
+        const payload = createDealPayload({
+          externalId: `null-seller-user-${Date.now()}`,
+          seller: {
+            id: 'SEL-NULL-002',
+            name: 'Null Test Seller',
+            externalUserId: null
+          }
+        });
+        const { status, data } = await request('POST', '/deals', payload);
+        assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+        createdDeals.push(data.result.dealId);
+      });
+
+      it('should accept null external_id in account (snake_case)', async () => {
+        const payload = createDealPayload({
+          externalId: `null-account-ext-${Date.now()}`,
+          account: {
+            user_id: 'USR-NULL-001',
+            company_name: 'Null Test Company',
+            external_id: null
+          }
+        });
+        const { status, data } = await request('POST', '/deals', payload);
+        assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+        createdDeals.push(data.result.dealId);
+      });
+    });
+
+    describe('3.2 Empty strings', () => {
+      it('should accept empty string externalId in seller', async () => {
+        const payload = createDealPayload({
+          externalId: `empty-seller-ext-${Date.now()}`,
+          seller: {
+            id: 'SEL-EMPTY-001',
+            name: 'Empty Test Seller',
+            externalId: ''
+          }
+        });
+        const { status, data } = await request('POST', '/deals', payload);
+        assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+        createdDeals.push(data.result.dealId);
+      });
+
+      it('should accept empty string externalUserId in account', async () => {
+        const payload = createDealPayload({
+          externalId: `empty-account-user-${Date.now()}`,
+          account: {
+            userId: 'USR-EMPTY-001',
+            companyName: 'Empty Test Company',
+            externalUserId: ''
+          }
+        });
+        const { status, data } = await request('POST', '/deals', payload);
+        assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+        createdDeals.push(data.result.dealId);
+      });
+    });
+
+    describe('3.3 Omitted fields', () => {
+      let dealId;
+
+      it('should create deal with seller without externalId/externalUserId', async () => {
+        const payload = createDealPayload({
+          externalId: `omit-seller-${Date.now()}`,
+          seller: {
+            id: 'SEL-OMIT-001',
+            name: 'Omit Test Seller'
+          }
+        });
+        const { status, data } = await request('POST', '/deals', payload);
+        assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+        dealId = data.result.dealId;
+        createdDeals.push(dealId);
+      });
+
+      it('should not have externalId/externalUserId in response when omitted', async () => {
+        const { status, data } = await request('GET', `/deals/${dealId}`);
+        assert.strictEqual(status, 200);
+        assert.ok(!('externalId' in data.result.seller) || data.result.seller.externalId === undefined);
+        assert.ok(!('externalUserId' in data.result.seller) || data.result.seller.externalUserId === undefined);
+      });
+
+      it('should create deal with account without external IDs', async () => {
+        const payload = createDealPayload({
+          externalId: `omit-account-${Date.now()}`,
+          account: {
+            userId: 'USR-OMIT-001',
+            companyName: 'Omit Test Company'
+          }
+        });
+        const { status, data } = await request('POST', '/deals', payload);
+        assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+        createdDeals.push(data.result.dealId);
+      });
+    });
+
+    describe('3.4 Mixed case inputs', () => {
+      it('should accept mixed camelCase and snake_case in same seller object', async () => {
+        const payload = createDealPayload({
+          externalId: `mixed-seller-${Date.now()}`,
+          seller: {
+            id: 'SEL-MIXED-001',
+            name: 'Mixed Test Seller',
+            externalId: 'EXT-CAMEL',
+            external_user_id: 'USR-SNAKE'
+          }
+        });
+        const { status, data } = await request('POST', '/deals', payload);
+        assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+        createdDeals.push(data.result.dealId);
+        
+        const { data: getData } = await request('GET', `/deals/${data.result.dealId}`);
+        assert.strictEqual(getData.result.seller.externalId, 'EXT-CAMEL');
+        assert.strictEqual(getData.result.seller.externalUserId, 'USR-SNAKE');
+      });
+
+      it('should accept mixed camelCase and snake_case in same account object', async () => {
+        const payload = createDealPayload({
+          externalId: `mixed-account-${Date.now()}`,
+          account: {
+            userId: 'USR-MIXED-001',
+            company_name: 'Mixed Test Company',
+            externalId: 'ACC-CAMEL',
+            external_user_id: 'USR-ACC-SNAKE'
+          }
+        });
+        const { status, data } = await request('POST', '/deals', payload);
+        assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+        createdDeals.push(data.result.dealId);
+        
+        const { data: getData } = await request('GET', `/deals/${data.result.dealId}`);
+        assert.strictEqual(getData.result.account.externalId, 'ACC-CAMEL');
+        assert.strictEqual(getData.result.account.externalUserId, 'USR-ACC-SNAKE');
+      });
+    });
+  });
+
+  describe('4. Deal Update Tests', () => {
+    let dealId;
+
+    before(async () => {
+      const payload = createDealPayload({
+        externalId: `update-test-${Date.now()}`,
+        seller: {
+          id: 'SEL-UPDATE-001',
+          name: 'Update Test Seller',
+          externalId: 'ORIGINAL-SEL-EXT',
+          externalUserId: 'ORIGINAL-SEL-USR'
+        },
+        account: {
+          userId: 'USR-UPDATE-001',
+          companyName: 'Update Test Company',
+          externalId: 'ORIGINAL-ACC-EXT',
+          externalUserId: 'ORIGINAL-ACC-USR'
+        }
+      });
+      const { data } = await request('POST', '/deals', payload);
+      dealId = data.result.dealId;
+      createdDeals.push(dealId);
+    });
+
+    it('should update seller externalId via PUT', async () => {
+      const { status, data } = await request('PUT', `/deals/${dealId}`, {
+        seller: {
+          id: 'SEL-UPDATE-001',
+          name: 'Update Test Seller',
+          externalId: 'UPDATED-SEL-EXT',
+          externalUserId: 'ORIGINAL-SEL-USR'
+        }
+      });
+      assert.strictEqual(status, 200, `Failed: ${JSON.stringify(data)}`);
+      
+      const { data: getData } = await request('GET', `/deals/${dealId}`);
+      assert.strictEqual(getData.result.seller.externalId, 'UPDATED-SEL-EXT');
+    });
+
+    it('should update account external_id via PUT (snake_case)', async () => {
+      const { status, data } = await request('PUT', `/deals/${dealId}`, {
+        account: {
+          user_id: 'USR-UPDATE-001',
+          company_name: 'Update Test Company',
+          external_id: 'UPDATED-ACC-EXT',
+          external_user_id: 'UPDATED-ACC-USR'
+        }
+      });
+      assert.strictEqual(status, 200, `Failed: ${JSON.stringify(data)}`);
+      
+      const { data: getData } = await request('GET', `/deals/${dealId}`);
+      assert.strictEqual(getData.result.account.externalId, 'UPDATED-ACC-EXT');
+      assert.strictEqual(getData.result.account.externalUserId, 'UPDATED-ACC-USR');
+    });
+  });
+
+  describe('5. PROGRAMMATIC Mode Tests', () => {
+    it('should accept seller/account external IDs in PROGRAMMATIC mode', async () => {
+      const payload = {
+        name: `Programmatic Test ${Date.now()}`,
+        externalId: `prog-ext-${Date.now()}`,
+        source: 'e2e-test',
+        mode: 'PROGRAMMATIC',
+        dealType: 'GUARANTEED',
+        currency: 'USD',
+        seller: {
+          id: 'SEL-PROG-001',
+          name: 'Programmatic Seller',
+          externalId: 'PROG-SEL-EXT-001',
+          externalUserId: 'PROG-SEL-USR-001'
+        },
+        account: {
+          userId: 'USR-PROG-001',
+          companyName: 'Programmatic Company',
+          externalId: 'PROG-ACC-EXT-001',
+          externalUserId: 'PROG-ACC-USR-001'
+        },
+        programmatic: {
+          buyers: [{ id: 'buyer-001', name: 'Test Buyer' }],
+          transactionType: 'SPOT',
+          costType: 'CPM'
+        }
+      };
+      const { status, data } = await request('POST', '/deals', payload);
+      assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+      createdDeals.push(data.result.dealId);
+      
+      const { data: getData } = await request('GET', `/deals/${data.result.dealId}`);
+      assert.strictEqual(getData.result.seller.externalId, 'PROG-SEL-EXT-001');
+      assert.strictEqual(getData.result.seller.externalUserId, 'PROG-SEL-USR-001');
+      assert.strictEqual(getData.result.account.externalId, 'PROG-ACC-EXT-001');
+      assert.strictEqual(getData.result.account.externalUserId, 'PROG-ACC-USR-001');
+    });
+  });
+
+  describe('6. List Deals Tests', () => {
+    it('should return seller/account external IDs in deal list', async () => {
+      const extId = `list-test-${Date.now()}`;
+      const payload = createDealPayload({
+        externalId: extId,
+        seller: {
+          id: 'SEL-LIST-001',
+          name: 'List Test Seller',
+          externalId: 'LIST-SEL-EXT',
+          externalUserId: 'LIST-SEL-USR'
+        },
+        account: {
+          userId: 'USR-LIST-001',
+          companyName: 'List Test Company',
+          externalId: 'LIST-ACC-EXT',
+          externalUserId: 'LIST-ACC-USR'
+        }
+      });
+      const { data: createData } = await request('POST', '/deals', payload);
+      const dealId = createData.result.dealId;
+      createdDeals.push(dealId);
+      
+      const { status, data } = await request('GET', `/deals?externalId=${extId}`);
+      assert.strictEqual(status, 200);
+      
+      const deal = data.result.data.find(d => d.dealId === dealId);
+      assert.ok(deal, 'Created deal should be in list');
+      assert.strictEqual(deal.seller.externalId, 'LIST-SEL-EXT');
+      assert.strictEqual(deal.seller.externalUserId, 'LIST-SEL-USR');
+      assert.strictEqual(deal.account.externalId, 'LIST-ACC-EXT');
+      assert.strictEqual(deal.account.externalUserId, 'LIST-ACC-USR');
+    });
+  });
+
+  describe('7. Sync Endpoint Tests', () => {
+    it('should sync deal with seller external IDs (camelCase)', async () => {
+      const payload = [{
+        deal: {
+          externalId: `sync-camel-${Date.now()}`,
+          name: 'Sync Test Deal CamelCase',
+          mode: 'PROGRAMMATIC',
+          dealType: 'GUARANTEED',
+          currency: 'USD',
+          source: 'sync-test',
+          seller: {
+            id: 'SEL-SYNC-001',
+            name: 'Sync Seller',
+            externalId: 'SYNC-SEL-EXT-001',
+            externalUserId: 'SYNC-SEL-USR-001'
+          },
+          account: {
+            userId: 'USR-SYNC-001',
+            companyName: 'Sync Company',
+            externalId: 'SYNC-ACC-EXT-001',
+            externalUserId: 'SYNC-ACC-USR-001'
+          },
+          programmatic: {
+            buyers: [{ id: 'buyer-sync', name: 'Sync Buyer' }],
+            transactionType: 'SPOT',
+            costType: 'CPM'
+          }
+        }
+      }];
+      
+      const { status, data } = await request('POST', '/deals/sync', payload);
+      assert.strictEqual(status, 200, `Failed: ${JSON.stringify(data)}`);
+      assert.strictEqual(data.result.successful, 1);
+      const dealId = data.result.items.deal_id;
+      createdDeals.push(dealId);
+      
+      const { data: getData } = await request('GET', `/deals/${dealId}`);
+      assert.strictEqual(getData.result.seller.externalId, 'SYNC-SEL-EXT-001');
+      assert.strictEqual(getData.result.seller.externalUserId, 'SYNC-SEL-USR-001');
+      assert.strictEqual(getData.result.account.externalId, 'SYNC-ACC-EXT-001');
+      assert.strictEqual(getData.result.account.externalUserId, 'SYNC-ACC-USR-001');
+    });
+
+    it('should sync deal with seller/account external IDs (snake_case)', async () => {
+      const payload = [{
+        deal: {
+          external_id: `sync-snake-${Date.now()}`,
+          name: 'Sync Test Deal SnakeCase',
+          mode: 'PROGRAMMATIC',
+          deal_type: 'GUARANTEED',
+          currency: 'USD',
+          source: 'sync-test',
+          seller: {
+            id: 'SEL-SYNC-002',
+            name: 'Sync Seller Snake',
+            external_id: 'SYNC-SEL-EXT-SNAKE',
+            external_user_id: 'SYNC-SEL-USR-SNAKE'
+          },
+          account: {
+            user_id: 'USR-SYNC-002',
+            company_name: 'Sync Company Snake',
+            external_id: 'SYNC-ACC-EXT-SNAKE',
+            external_user_id: 'SYNC-ACC-USR-SNAKE'
+          },
+          programmatic: {
+            buyers: [{ id: 'buyer-sync-2', name: 'Sync Buyer 2' }],
+            transaction_type: 'SPOT',
+            cost_type: 'CPM'
+          }
+        }
+      }];
+      
+      const { status, data } = await request('POST', '/deals/sync', payload);
+      assert.strictEqual(status, 200, `Failed: ${JSON.stringify(data)}`);
+      assert.strictEqual(data.result.successful, 1);
+      const dealId = data.result.items.deal_id;
+      createdDeals.push(dealId);
+      
+      const { data: getData } = await request('GET', `/deals/${dealId}`);
+      assert.strictEqual(getData.result.seller.externalId, 'SYNC-SEL-EXT-SNAKE');
+      assert.strictEqual(getData.result.seller.externalUserId, 'SYNC-SEL-USR-SNAKE');
+      assert.strictEqual(getData.result.account.externalId, 'SYNC-ACC-EXT-SNAKE');
+      assert.strictEqual(getData.result.account.externalUserId, 'SYNC-ACC-USR-SNAKE');
+    });
+
+    it('should update deal via sync preserving external IDs', async () => {
+      const extId = `sync-update-${Date.now()}`;
+      const createPayload = [{
+        deal: {
+          externalId: extId,
+          name: 'Sync Update Test',
+          mode: 'PROGRAMMATIC',
+          dealType: 'GUARANTEED',
+          currency: 'USD',
+          source: 'sync-test',
+          seller: {
+            id: 'SEL-SYNC-UPD',
+            name: 'Sync Seller Update',
+            externalId: 'ORIGINAL-EXT',
+            externalUserId: 'ORIGINAL-USR'
+          },
+          programmatic: {
+            buyers: [{ id: 'buyer-upd', name: 'Update Buyer' }],
+            transactionType: 'SPOT',
+            costType: 'CPM'
+          }
+        }
+      }];
+      
+      const { data: createData } = await request('POST', '/deals/sync', createPayload);
+      const createdDealId = createData.result.items.deal_id;
+      createdDeals.push(createdDealId);
+      
+      const updatePayload = [{
+        deal: {
+          externalId: extId,
+          name: 'Sync Update Test - Updated',
+          mode: 'PROGRAMMATIC',
+          dealType: 'GUARANTEED',
+          currency: 'USD',
+          source: 'sync-test',
+          seller: {
+            id: 'SEL-SYNC-UPD',
+            name: 'Sync Seller Update',
+            externalId: 'UPDATED-EXT',
+            externalUserId: 'UPDATED-USR'
+          },
+          programmatic: {
+            buyers: [{ id: 'buyer-upd', name: 'Update Buyer' }],
+            transactionType: 'SPOT',
+            costType: 'CPM'
+          }
+        }
+      }];
+      
+      const { status, data } = await request('POST', '/deals/sync', updatePayload);
+      assert.strictEqual(status, 200, `Failed: ${JSON.stringify(data)}`);
+      assert.strictEqual(data.result.successful, 1);
+      
+      const { data: getData } = await request('GET', `/deals/${createdDealId}`);
+      assert.strictEqual(getData.result.name, 'Sync Update Test - Updated');
+      assert.strictEqual(getData.result.seller.externalId, 'UPDATED-EXT');
+      assert.strictEqual(getData.result.seller.externalUserId, 'UPDATED-USR');
+    });
+  });
+
+  describe('8. Import Endpoint Tests', () => {
+    it('should import campaign with seller external IDs via PROGRAMMATIC_STANDARD', async () => {
+      const payload = {
+        payloadType: 'PROGRAMMATIC_STANDARD',
+        externalPayload: {
+          campaign: {
+            externalId: `import-prog-${Date.now()}`,
+            name: 'Import Programmatic Test',
+            dealType: 'GUARANTEED',
+            currency: 'USD',
+            seller: {
+              id: 'SEL-IMPORT-001',
+              name: 'Import Seller',
+              externalId: 'IMP-SEL-EXT-001',
+              externalUserId: 'IMP-SEL-USR-001'
+            },
+            account: {
+              userId: 'USR-IMPORT-001',
+              companyName: 'Import Company',
+              externalId: 'IMP-ACC-EXT-001',
+              externalUserId: 'IMP-ACC-USR-001'
+            },
+            buyers: [{ id: 'buyer-imp', name: 'Import Buyer' }],
+            transactionType: 'SPOT',
+            costType: 'CPM'
+          },
+          lineItems: [{
+            externalId: `import-li-${Date.now()}`,
+            name: 'Import Line Item',
+            creativeType: 'DISPLAY',
+            duration: 15,
+            startDate: '2026-01-01',
+            endDate: '2026-03-31',
+            resolutions: ['1920x1080']
+          }]
+        },
+        options: { source: 'import-test' }
+      };
+      
+      const { status, data } = await request('POST', '/deals/import', payload);
+      assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+      createdDeals.push(data.result.deal.id);
+      
+      const { data: getData } = await request('GET', `/deals/${data.result.deal.id}`);
+      assert.strictEqual(getData.result.seller.externalId, 'IMP-SEL-EXT-001');
+      assert.strictEqual(getData.result.seller.externalUserId, 'IMP-SEL-USR-001');
+      assert.strictEqual(getData.result.account.externalId, 'IMP-ACC-EXT-001');
+      assert.strictEqual(getData.result.account.externalUserId, 'IMP-ACC-USR-001');
+    });
+
+    it('should import campaign with seller external IDs (snake_case) via PROGRAMMATIC_STANDARD', async () => {
+      const payload = {
+        payloadType: 'PROGRAMMATIC_STANDARD',
+        externalPayload: {
+          campaign: {
+            external_id: `import-prog-snake-${Date.now()}`,
+            name: 'Import Programmatic Snake Test',
+            deal_type: 'PRIVATE_AUCTION',
+            currency: 'USD',
+            seller: {
+              id: 'SEL-PROG-SNAKE',
+              name: 'Prog Snake Seller',
+              external_id: 'PROG-SEL-EXT-SNAKE',
+              external_user_id: 'PROG-SEL-USR-SNAKE'
+            },
+            account: {
+              user_id: 'USR-PROG-SNAKE',
+              company_name: 'Prog Snake Company',
+              external_id: 'PROG-ACC-EXT-SNAKE',
+              external_user_id: 'PROG-ACC-USR-SNAKE'
+            },
+            buyers: [{ id: 'buyer-snake', name: 'Snake Buyer' }],
+            transaction_type: 'SPOT',
+            cost_type: 'CPM'
+          },
+          lineItems: [{
+            external_id: `import-li-snake-${Date.now()}`,
+            name: 'Import Line Item Snake',
+            creative_type: 'DISPLAY',
+            duration: 15,
+            start_date: '2026-01-01',
+            end_date: '2026-03-31',
+            resolutions: ['1920x1080']
+          }]
+        },
+        options: { source: 'import-test' }
+      };
+      
+      const { status, data } = await request('POST', '/deals/import', payload);
+      assert.strictEqual(status, 201, `Failed: ${JSON.stringify(data)}`);
+      createdDeals.push(data.result.deal.id);
+      
+      const { data: getData } = await request('GET', `/deals/${data.result.deal.id}`);
+      assert.strictEqual(getData.result.seller.externalId, 'PROG-SEL-EXT-SNAKE');
+      assert.strictEqual(getData.result.seller.externalUserId, 'PROG-SEL-USR-SNAKE');
+      assert.strictEqual(getData.result.account.externalId, 'PROG-ACC-EXT-SNAKE');
+      assert.strictEqual(getData.result.account.externalUserId, 'PROG-ACC-USR-SNAKE');
+    });
+  });
+});