adserver-dashboard 1.0.0

package/PCM/tests/direct-publisher-split-reimport.test.js

@@ -0,0 +1,460 @@
+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 response = await fetch(`${BASE_URL}${path}`, options);
+  const data = await response.json();
+  return { status: response.status, data };
+}
+
+function createImportPayload(campaignId, inventories, overrides = {}) {
+  return {
+    payloadType: 'DIRECT_PUBLISHER_SPLIT',
+    externalPayload: {
+      campaign: {
+        externalId: campaignId,
+        name: overrides.name || `Reimport Test Campaign ${campaignId}`,
+        brand: 'Test Brand',
+        clientType: 'AGENCY',
+        approvalEmails: ['test@example.com'],
+        marketSelection: { country: 'MY', currency: 'MYR' },
+        budgetSetup: { currency: 'MYR', budgetAmount: 100000 },
+        campaignGoal: { type: 'IMPRESSIONS', targetValue: 1000000 },
+        startDate: '2026-01-01T00:00:00Z',
+        endDate: '2026-12-31T23:59:59Z',
+        ...overrides.campaign
+      },
+      inventories
+    },
+    options: { source: overrides.source || 'external-test' }
+  };
+}
+
+function createInternalDealPayload(externalId, name = 'Internal Test Deal') {
+  return {
+    source: 'influence',
+    externalId,
+    name,
+    mode: 'DIRECT',
+    dealType: 'GUARANTEED',
+    status: 'DRAFT',
+    brand: 'Test Brand',
+    clientType: 'AGENCY',
+    currency: 'MYR',
+    marketSelection: { country: 'MY', currency: 'MYR' },
+    budgetSetup: { currency: 'MYR', budgetAmount: 10000 },
+    campaignGoal: { type: 'IMPRESSIONS', targetValue: 100000 }
+  };
+}
+
+async function reopenDeal(dealId) {
+  await request('PUT', `/deals/${dealId}`, { status: 'APPROVED' });
+  const { status, data } = await request('POST', `/deals/${dealId}/reopen`, { reason: 'For testing' });
+  return { status, data };
+}
+
+const createdDeals = [];
+
+describe('DIRECT_PUBLISHER_SPLIT Comprehensive Test Suite', () => {
+  
+  after(async () => {
+    for (const dealId of createdDeals) {
+      try {
+        await request('DELETE', `/deals/${dealId}`);
+      } catch (e) {}
+    }
+  });
+
+  describe('1. Fresh Import (INSERT) Tests', () => {
+    it('should create new deal with external source', async () => {
+      const campaignId = `fresh-ext-${Date.now()}`;
+      const inventories = [
+        { id: 'inv-1', name: 'Screen 1', resolution: '1920x1080', publisher: { id: 'pub-001', name: 'Publisher One' } }
+      ];
+      
+      const { status, data } = await request('POST', '/deals/import', createImportPayload(campaignId, inventories));
+      assert.strictEqual(status, 201);
+      createdDeals.push(data.result.deal.id);
+      
+      assert.strictEqual(data.result.summary.isUpdate, false);
+      assert.strictEqual(data.result.deal.source, 'external-test');
+      assert.strictEqual(data.result.deal.mode, 'DIRECT');
+    });
+
+    it('should create multiple line items for multiple publishers', async () => {
+      const campaignId = `multi-pub-${Date.now()}`;
+      const inventories = [
+        { id: 'inv-1', name: 'Screen 1', resolution: '1920x1080', publisher: { id: 'pub-001', name: 'Publisher One' } },
+        { id: 'inv-2', name: 'Screen 2', resolution: '1920x1080', publisher: { id: 'pub-002', name: 'Publisher Two' } },
+        { id: 'inv-3', name: 'Screen 3', resolution: '3840x2160', publisher: { id: 'pub-001', name: 'Publisher One' } }
+      ];
+      
+      const { status, data } = await request('POST', '/deals/import', createImportPayload(campaignId, inventories));
+      assert.strictEqual(status, 201);
+      createdDeals.push(data.result.deal.id);
+      
+      assert.strictEqual(data.result.summary.lineItemsProcessed, 2, 'Should create 2 line items (grouped by publisher+duration)');
+      assert.strictEqual(data.result.summary.insertionOrdersCreated, 2, 'Should create 2 insertion orders');
+    });
+
+    it('should populate publishers array from inventories', async () => {
+      const campaignId = `publishers-${Date.now()}`;
+      const inventories = [
+        { id: 'inv-1', name: 'Screen 1', resolution: '1920x1080', publisher: { id: 'pub-001', name: 'Publisher One', externalId: 'EXT-001' } },
+        { id: 'inv-2', name: 'Screen 2', resolution: '1920x1080', publisher: { id: 'pub-002', name: 'Publisher Two', externalId: 'EXT-002' } }
+      ];
+      
+      const { status, data } = await request('POST', '/deals/import', createImportPayload(campaignId, inventories));
+      assert.strictEqual(status, 201);
+      createdDeals.push(data.result.deal.id);
+      
+      assert.strictEqual(data.result.deal.publishers.length, 2);
+      const pub1 = data.result.deal.publishers.find(p => p.id === 'pub-001');
+      assert.strictEqual(pub1.externalId, 'EXT-001');
+    });
+
+    it('should create insertion orders for each publisher', async () => {
+      const campaignId = `ios-${Date.now()}`;
+      const inventories = [
+        { id: 'inv-1', name: 'Screen 1', resolution: '1920x1080', publisher: { id: 'pub-001', name: 'Publisher One' } },
+        { id: 'inv-2', name: 'Screen 2', resolution: '1920x1080', publisher: { id: 'pub-002', name: 'Publisher Two' } }
+      ];
+      
+      const { status, data } = await request('POST', '/deals/import', createImportPayload(campaignId, inventories));
+      assert.strictEqual(status, 201);
+      createdDeals.push(data.result.deal.id);
+      const dealId = data.result.deal.dealId;
+      
+      const { data: dealData } = await request('GET', `/deals/${dealId}`);
+      assert.strictEqual(dealData.result.insertionOrders.length, 2);
+    });
+  });
+
+  describe('2. Upsert Status Restriction Tests', () => {
+    it('should reject upsert when deal is in DRAFT status', async () => {
+      const campaignId = `draft-reject-${Date.now()}`;
+      const inventories = [
+        { id: 'inv-1', name: 'Screen 1', resolution: '1920x1080', publisher: { id: 'pub-001', name: 'Publisher One' } }
+      ];
+      
+      const { status: status1, data: data1 } = await request('POST', '/deals/import', createImportPayload(campaignId, inventories));
+      assert.strictEqual(status1, 201);
+      createdDeals.push(data1.result.deal.id);
+      
+      const { status: status2, data: data2 } = await request('POST', '/deals/import', createImportPayload(campaignId, inventories));
+      
+      assert.strictEqual(status2, 409);
+      assert.strictEqual(data2.code, 'UPSERT_NOT_ALLOWED');
+      assert.strictEqual(data2.currentStatus, 'DRAFT');
+      assert.strictEqual(data2.requiredStatus, 'REOPENED');
+    });
+
+    it('should reject upsert when deal is in APPROVED status', async () => {
+      const campaignId = `approved-reject-${Date.now()}`;
+      const inventories = [
+        { id: 'inv-1', name: 'Screen 1', resolution: '1920x1080', publisher: { id: 'pub-001', name: 'Publisher One' } }
+      ];
+      
+      const { status: status1, data: data1 } = await request('POST', '/deals/import', createImportPayload(campaignId, inventories));
+      assert.strictEqual(status1, 201);
+      createdDeals.push(data1.result.deal.id);
+      const dealId = data1.result.deal.dealId;
+      
+      await request('PUT', `/deals/${dealId}`, { status: 'APPROVED' });
+      
+      const { status: status2, data: data2 } = await request('POST', '/deals/import', createImportPayload(campaignId, inventories));
+      
+      assert.strictEqual(status2, 409);
+      assert.strictEqual(data2.currentStatus, 'APPROVED');
+    });
+
+    it('should allow upsert when deal is in REOPENED status', async () => {
+      const campaignId = `reopened-allow-${Date.now()}`;
+      const inventories = [
+        { id: 'inv-1', name: 'Screen 1', resolution: '1920x1080', publisher: { id: 'pub-001', name: 'Publisher One' } }
+      ];
+      
+      const { status: status1, data: data1 } = await request('POST', '/deals/import', createImportPayload(campaignId, inventories));
+      assert.strictEqual(status1, 201);
+      createdDeals.push(data1.result.deal.id);
+      const dealId = data1.result.deal.dealId;
+      
+      const { status: reopenStatus } = await reopenDeal(dealId);
+      assert.strictEqual(reopenStatus, 200, 'Reopen should succeed');
+      
+      const newInventories = [
+        { id: 'inv-1', name: 'Screen 1', resolution: '1920x1080', publisher: { id: 'pub-001', name: 'Publisher One' } },
+        { id: 'inv-2', name: 'Screen 2', resolution: '1920x1080', publisher: { id: 'pub-002', name: 'Publisher Two' } }
+      ];
+      
+      const { status: status2, data: data2 } = await request('POST', '/deals/import', createImportPayload(campaignId, newInventories));
+      
+      assert.strictEqual(status2, 201, `Upsert should succeed: ${JSON.stringify(data2)}`);
+      assert.strictEqual(data2.result.summary.isUpdate, true);
+    });
+  });
+
+  describe('3. External Source Re-Import Tests', () => {
+    it('should allow external source to reopen and re-import', async () => {
+      const campaignId = `ext-reimport-${Date.now()}`;
+      const inventories = [
+        { id: 'inv-1', name: 'Screen 1', resolution: '1920x1080', publisher: { id: 'pub-001', name: 'Publisher One' } }
+      ];
+      
+      const { status: status1, data: data1 } = await request('POST', '/deals/import', createImportPayload(campaignId, inventories, { source: 'broadsign' }));
+      assert.strictEqual(status1, 201);
+      createdDeals.push(data1.result.deal.id);
+      const dealId = data1.result.deal.dealId;
+      
+      const { status: reopenStatus, data: reopenData } = await reopenDeal(dealId);
+      assert.strictEqual(reopenStatus, 200, `Reopen failed: ${JSON.stringify(reopenData)}`);
+      
+      const newInventories = [
+        { id: 'inv-1', name: 'Screen 1', resolution: '1920x1080', publisher: { id: 'pub-001', name: 'Publisher One' } },
+        { id: 'inv-2', name: 'Screen 2', resolution: '1920x1080', publisher: { id: 'pub-002', name: 'Publisher Two' } }
+      ];
+      
+      const { status: status2, data: data2 } = await request('POST', '/deals/import', createImportPayload(campaignId, newInventories, { source: 'broadsign' }));
+      
+      assert.strictEqual(status2, 201, `Re-import failed: ${JSON.stringify(data2)}`);
+      assert.strictEqual(data2.result.summary.isUpdate, true);
+      assert.strictEqual(data2.result.summary.insertionOrdersCreated, 1);
+    });
+  });
+
+  describe('4. Archiving Logic Tests', () => {
+    it('should archive line items when publisher is removed', async () => {
+      const campaignId = `archive-li-${Date.now()}`;
+      const inventories = [
+        { id: 'inv-1', name: 'Screen 1', resolution: '1920x1080', publisher: { id: 'pub-001', name: 'Publisher One' } },
+        { id: 'inv-2', name: 'Screen 2', resolution: '1920x1080', publisher: { id: 'pub-002', name: 'Publisher Two' } }
+      ];
+      
+      const { status: status1, data: data1 } = await request('POST', '/deals/import', createImportPayload(campaignId, inventories));
+      assert.strictEqual(status1, 201);
+      createdDeals.push(data1.result.deal.id);
+      const dealId = data1.result.deal.dealId;
+      
+      await reopenDeal(dealId);
+      
+      const reducedInventories = [
+        { id: 'inv-1', name: 'Screen 1', resolution: '1920x1080', publisher: { id: 'pub-001', name: 'Publisher One' } }
+      ];
+      
+      const { status: status2, data: data2 } = await request('POST', '/deals/import', createImportPayload(campaignId, reducedInventories));
+      assert.strictEqual(status2, 201);
+      assert.strictEqual(data2.result.summary.lineItemsArchived, 1);
+      
+      const { data: dealData } = await request('GET', `/deals/${dealId}?embed=lineItems`);
+      const archivedItems = dealData.result.lineItems.filter(li => li.status === 'ARCHIVED');
+      assert.strictEqual(archivedItems.length, 1);
+    });
+
+    it('should archive insertion orders when publisher is removed', async () => {
+      const campaignId = `archive-io-${Date.now()}`;
+      const inventories = [
+        { id: 'inv-1', name: 'Screen 1', resolution: '1920x1080', publisher: { id: 'pub-001', name: 'Publisher One' } },
+        { id: 'inv-2', name: 'Screen 2', resolution: '1920x1080', publisher: { id: 'pub-002', name: 'Publisher Two' } }
+      ];
+      
+      const { status: status1, data: data1 } = await request('POST', '/deals/import', createImportPayload(campaignId, inventories));
+      assert.strictEqual(status1, 201);
+      createdDeals.push(data1.result.deal.id);
+      const dealId = data1.result.deal.dealId;
+      
+      await reopenDeal(dealId);
+      
+      const reducedInventories = [
+        { id: 'inv-1', name: 'Screen 1', resolution: '1920x1080', publisher: { id: 'pub-001', name: 'Publisher One' } }
+      ];
+      
+      const { status: status2, data: data2 } = await request('POST', '/deals/import', createImportPayload(campaignId, reducedInventories));
+      assert.strictEqual(status2, 201);
+      assert.strictEqual(data2.result.summary.insertionOrdersArchived, 1);
+    });
+
+    it('should reactivate archived insertion order when publisher returns', async () => {
+      const campaignId = `reactivate-io-${Date.now()}`;
+      const inventories = [
+        { id: 'inv-1', name: 'Screen 1', resolution: '1920x1080', publisher: { id: 'pub-001', name: 'Publisher One' } },
+        { id: 'inv-2', name: 'Screen 2', resolution: '1920x1080', publisher: { id: 'pub-002', name: 'Publisher Two' } }
+      ];
+      
+      const { data: data1 } = await request('POST', '/deals/import', createImportPayload(campaignId, inventories));
+      createdDeals.push(data1.result.deal.id);
+      const dealId = data1.result.deal.dealId;
+      
+      await reopenDeal(dealId);
+      
+      await request('POST', '/deals/import', createImportPayload(campaignId, [inventories[0]]));
+      
+      await reopenDeal(dealId);
+      
+      const { status, data: data3 } = await request('POST', '/deals/import', createImportPayload(campaignId, inventories));
+      assert.strictEqual(status, 201);
+      
+      const { data: dealData } = await request('GET', `/deals/${dealId}`);
+      const activeIOs = dealData.result.insertionOrders.filter(io => io.status !== 'ARCHIVED');
+      assert.strictEqual(activeIOs.length, 2, 'Both insertion orders should be active');
+    });
+  });
+
+  describe('5. Deterministic ExternalId Tests', () => {
+    it('should generate consistent externalId with inventory fingerprint', async () => {
+      const campaignId = `fingerprint-${Date.now()}`;
+      const inventories = [
+        { id: 'inv-a', name: 'Screen A', resolution: '1920x1080', publisher: { id: 'pub-001', name: 'Publisher One' } },
+        { id: 'inv-b', name: 'Screen B', resolution: '1920x1080', publisher: { id: 'pub-001', name: 'Publisher One' } }
+      ];
+      
+      const { status, data } = await request('POST', '/deals/import', createImportPayload(campaignId, inventories));
+      assert.strictEqual(status, 201);
+      createdDeals.push(data.result.deal.id);
+      const dealId = data.result.deal.dealId;
+      
+      const { data: dealData } = await request('GET', `/deals/${dealId}?embed=lineItems`);
+      const externalId = dealData.result.lineItems[0]?.externalId;
+      
+      assert.ok(externalId, 'Should have externalId');
+      const parts = externalId.split('-');
+      assert.ok(parts.length >= 5, 'ExternalId should include fingerprint');
+    });
+
+    it('should preserve line item UUID on re-import with same inventories', async () => {
+      const campaignId = `preserve-uuid-${Date.now()}`;
+      const inventories = [
+        { id: 'inv-1', name: 'Screen 1', resolution: '1920x1080', publisher: { id: 'pub-001', name: 'Publisher One' } }
+      ];
+      
+      const { data: data1 } = await request('POST', '/deals/import', createImportPayload(campaignId, inventories));
+      createdDeals.push(data1.result.deal.id);
+      const dealId = data1.result.deal.dealId;
+      
+      const { data: lineItems1 } = await request('GET', `/deals/${dealId}?embed=lineItems`);
+      const originalUUID = lineItems1.result.lineItems[0]?.id;
+      
+      await reopenDeal(dealId);
+      
+      await request('POST', '/deals/import', createImportPayload(campaignId, inventories, { name: 'Updated Name' }));
+      
+      const { data: lineItems2 } = await request('GET', `/deals/${dealId}?embed=lineItems`);
+      const updatedUUID = lineItems2.result.lineItems[0]?.id;
+      
+      assert.strictEqual(originalUUID, updatedUUID, 'Line item UUID should be preserved');
+    });
+
+    it('should handle inventories without IDs using fallback fingerprint', async () => {
+      const campaignId = `no-id-${Date.now()}`;
+      const inventories = [
+        { name: 'Screen 1', resolution: '1920x1080', publisher: { id: 'pub-001', name: 'Publisher One' } },
+        { name: 'Screen 2', resolution: '1920x1080', publisher: { id: 'pub-001', name: 'Publisher One' } }
+      ];
+      
+      const { status, data } = await request('POST', '/deals/import', createImportPayload(campaignId, inventories));
+      assert.strictEqual(status, 201);
+      createdDeals.push(data.result.deal.id);
+      
+      assert.strictEqual(data.result.summary.lineItemsProcessed, 1);
+    });
+  });
+
+  describe('6. Summary Response Accuracy Tests', () => {
+    it('should return accurate summary for fresh import', async () => {
+      const campaignId = `summary-fresh-${Date.now()}`;
+      const inventories = [
+        { id: 'inv-1', name: 'Screen 1', resolution: '1920x1080', publisher: { id: 'pub-001', name: 'Publisher One' } },
+        { id: 'inv-2', name: 'Screen 2', resolution: '1920x1080', publisher: { id: 'pub-002', name: 'Publisher Two' } }
+      ];
+      
+      const { status, data } = await request('POST', '/deals/import', createImportPayload(campaignId, inventories));
+      assert.strictEqual(status, 201);
+      createdDeals.push(data.result.deal.id);
+      
+      const summary = data.result.summary;
+      assert.strictEqual(summary.isUpdate, false);
+      assert.strictEqual(summary.lineItemsProcessed, 2);
+      assert.strictEqual(summary.lineItemsArchived, 0);
+      assert.strictEqual(summary.insertionOrdersCreated, 2);
+      assert.strictEqual(summary.insertionOrdersArchived, 0);
+    });
+
+    it('should return accurate summary for update import', async () => {
+      const campaignId = `summary-update-${Date.now()}`;
+      const inventories1 = [
+        { id: 'inv-1', name: 'Screen 1', resolution: '1920x1080', publisher: { id: 'pub-001', name: 'Publisher One' } },
+        { id: 'inv-2', name: 'Screen 2', resolution: '1920x1080', publisher: { id: 'pub-002', name: 'Publisher Two' } }
+      ];
+      
+      const { data: data1 } = await request('POST', '/deals/import', createImportPayload(campaignId, inventories1));
+      createdDeals.push(data1.result.deal.id);
+      const dealId = data1.result.deal.dealId;
+      
+      await reopenDeal(dealId);
+      
+      const inventories2 = [
+        { id: 'inv-1', name: 'Screen 1', resolution: '1920x1080', publisher: { id: 'pub-001', name: 'Publisher One' } }
+      ];
+      
+      const { status, data } = await request('POST', '/deals/import', createImportPayload(campaignId, inventories2));
+      assert.strictEqual(status, 201);
+      
+      const summary = data.result.summary;
+      assert.strictEqual(summary.isUpdate, true);
+      assert.strictEqual(summary.lineItemsProcessed, 1);
+      assert.strictEqual(summary.lineItemsArchived, 1);
+      assert.strictEqual(summary.insertionOrdersArchived, 1);
+    });
+  });
+
+  describe('7. Internal Source Workflow Tests', () => {
+    it('should allow internal source to reopen deals', async () => {
+      const externalId = `internal-reopen-${Date.now()}`;
+      const { status: createStatus, data: createData } = await request('POST', '/deals', createInternalDealPayload(externalId));
+      assert.strictEqual(createStatus, 201);
+      createdDeals.push(createData.result.id);
+      const dealId = createData.result.dealId;
+      
+      await request('PUT', `/deals/${dealId}`, { status: 'APPROVED' });
+      
+      const { status: reopenStatus, data: reopenData } = await request('POST', `/deals/${dealId}/reopen`, { reason: 'Testing' });
+      
+      assert.strictEqual(reopenStatus, 200, `Reopen failed: ${JSON.stringify(reopenData)}`);
+      assert.strictEqual(reopenData.result.currentStatus, 'REOPENED');
+    });
+  });
+
+  describe('8. Edge Case Tests', () => {
+    it('should handle different resolutions for same publisher', async () => {
+      const campaignId = `diff-res-${Date.now()}`;
+      const inventories = [
+        { id: 'inv-1', name: 'Screen 1', resolution: '1920x1080', publisher: { id: 'pub-001', name: 'Publisher One' } },
+        { id: 'inv-2', name: 'Screen 2', resolution: '3840x2160', publisher: { id: 'pub-001', name: 'Publisher One' } }
+      ];
+      
+      const { status, data } = await request('POST', '/deals/import', createImportPayload(campaignId, inventories));
+      assert.strictEqual(status, 201);
+      createdDeals.push(data.result.deal.id);
+      
+      assert.strictEqual(data.result.summary.lineItemsProcessed, 1, 'Should create one line item (same publisher+duration, multiple resolutions)');
+      assert.strictEqual(data.result.summary.insertionOrdersCreated, 1, 'Should create one insertion order for same publisher');
+    });
+
+    it('should reject empty inventories array', async () => {
+      const campaignId = `empty-inv-${Date.now()}`;
+      const inventories = [];
+      
+      const { status, data } = await request('POST', '/deals/import', createImportPayload(campaignId, inventories));
+      
+      assert.strictEqual(status, 400, 'Empty inventories should be rejected');
+    });
+  });
+});

package/PCM/tests/e2e/digital-signage.test.js

@@ -0,0 +1,145 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+
+const BASE_URL = 'http://localhost:5000';
+const API_V2_DS = `${BASE_URL}/api/v2/rest/ds`;
+
+const TEST_INVENTORY_ID = 'INV-INFLUENCE-000063';
+const TEST_DEVICE_ID = 'DEVICE-influence-pub-stroer-63';
+const TEST_REFERENCE_ID = 'REF-influence-pub-stroer-63';
+const TEST_DEAL_ID = 'DIR-INFLUENCE-00005-53805';
+const TEST_LINE_ITEM_ID = 'influence-li-15';
+
+describe('Digital Signage API E2E Tests', () => {
+  describe('GET /deals/:identifier', () => {
+    it('should return 404 for non-existent identifier', async () => {
+      const res = await fetch(`${API_V2_DS}/deals/non-existent-device-12345`);
+      const data = await res.json();
+
+      assert.strictEqual(res.status, 404);
+      assert.strictEqual(data.status, 404);
+      assert.ok(data.error.includes('No inventory or device found'));
+    });
+
+    it('should return campaigns for valid inventory ID', async () => {
+      const res = await fetch(`${API_V2_DS}/deals/${TEST_INVENTORY_ID}`);
+      const data = await res.json();
+
+      assert.strictEqual(res.status, 200);
+      assert.strictEqual(data.status, 200);
+      assert.ok(Array.isArray(data.result));
+      assert.ok(data.result.length > 0, 'Should return at least one campaign');
+      
+      const campaign = data.result[0];
+      assert.ok(campaign.name, 'Campaign should have name');
+      assert.ok(campaign.dealId, 'Campaign should have dealId');
+      assert.ok(campaign.mode, 'Campaign should have mode');
+      assert.ok(campaign.lineItem, 'Campaign should have lineItem');
+      assert.ok(campaign.publisher, 'Campaign should have publisher');
+      assert.ok(campaign.inventory, 'Campaign should have inventory');
+      assert.ok(Array.isArray(campaign.creatives), 'Campaign should have creatives array');
+    });
+
+    it('should return campaigns for valid device ID', async () => {
+      const res = await fetch(`${API_V2_DS}/deals/${TEST_DEVICE_ID}`);
+      const data = await res.json();
+
+      assert.strictEqual(res.status, 200);
+      assert.strictEqual(data.status, 200);
+      assert.ok(Array.isArray(data.result));
+      assert.ok(data.result.length > 0, 'Should return at least one campaign');
+    });
+
+    it('should return campaigns for valid reference ID', async () => {
+      const res = await fetch(`${API_V2_DS}/deals/${TEST_REFERENCE_ID}`);
+      const data = await res.json();
+
+      assert.strictEqual(res.status, 200);
+      assert.strictEqual(data.status, 200);
+      assert.ok(Array.isArray(data.result));
+      assert.ok(data.result.length > 0, 'Should return at least one campaign');
+    });
+
+    it('should include DIRECT specific fields for direct campaigns', async () => {
+      const res = await fetch(`${API_V2_DS}/deals/${TEST_INVENTORY_ID}`);
+      const data = await res.json();
+
+      const campaign = data.result.find(c => c.mode === 'direct');
+      if (campaign) {
+        assert.ok(campaign.direct, 'DIRECT campaign should have direct object');
+        assert.ok(campaign.deliveryTargeting, 'DIRECT campaign should have deliveryTargeting');
+        assert.ok(campaign.deliveryTargeting.ad_play_confirm_url, 'Should have ad_play_confirm_url');
+      }
+    });
+
+    it('should have correct inventory structure', async () => {
+      const res = await fetch(`${API_V2_DS}/deals/${TEST_INVENTORY_ID}`);
+      const data = await res.json();
+
+      assert.ok(data.result.length > 0, 'Should have results');
+      const campaign = data.result[0];
+      assert.ok(campaign.inventory.id, 'Inventory should have id');
+      assert.ok(campaign.inventory.deviceId, 'Inventory should have deviceId');
+      assert.ok(campaign.inventory.name, 'Inventory should have name');
+    });
+
+    it('should have correct publisher structure', async () => {
+      const res = await fetch(`${API_V2_DS}/deals/${TEST_INVENTORY_ID}`);
+      const data = await res.json();
+
+      assert.ok(data.result.length > 0, 'Should have results');
+      const campaign = data.result[0];
+      assert.ok(campaign.publisher.id, 'Publisher should have id');
+      assert.ok(campaign.publisher.name, 'Publisher should have name');
+    });
+
+    it('should have correct lineItem structure', async () => {
+      const res = await fetch(`${API_V2_DS}/deals/${TEST_INVENTORY_ID}`);
+      const data = await res.json();
+
+      assert.ok(data.result.length > 0, 'Should have results');
+      const campaign = data.result[0];
+      assert.ok(campaign.lineItem.id, 'LineItem should have id');
+      assert.ok(campaign.lineItem.name, 'LineItem should have name');
+      assert.ok(campaign.lineItem.creativeType, 'LineItem should have creativeType');
+    });
+
+    it('should have schedule and pacing data', async () => {
+      const res = await fetch(`${API_V2_DS}/deals/${TEST_INVENTORY_ID}`);
+      const data = await res.json();
+
+      assert.ok(data.result.length > 0, 'Should have results');
+      const campaign = data.result[0];
+      assert.ok(campaign.schedule, 'Campaign should have schedule');
+      assert.ok(campaign.pacing, 'Campaign should have pacing');
+    });
+
+    it('should exclude paused campaigns (is_playing = false)', async () => {
+      const res = await fetch(`${API_V2_DS}/deals/INV-INFLUENCE-000001`);
+      const data = await res.json();
+
+      assert.strictEqual(res.status, 200);
+      assert.strictEqual(data.result.length, 0, 'Should return empty array for paused campaigns');
+    });
+  });
+
+  describe('POST /confirm/:dealId/:lineItemId/:inventoryId', () => {
+    it('should return 404 for invalid confirmation', async () => {
+      const res = await fetch(
+        `${API_V2_DS}/confirm/invalid-deal/invalid-li/invalid-inv`,
+        { method: 'POST' }
+      );
+
+      assert.strictEqual(res.status, 404);
+    });
+
+    it('should return 204 for valid confirmation', async () => {
+      const res = await fetch(
+        `${API_V2_DS}/confirm/${TEST_DEAL_ID}/${TEST_LINE_ITEM_ID}/${TEST_INVENTORY_ID}`,
+        { method: 'POST' }
+      );
+
+      assert.strictEqual(res.status, 204);
+    });
+  });
+});