adserver-dashboard 1.0.0

package/PCM/tests/edge-cases.test.js

@@ -0,0 +1,340 @@
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert';
+import http from 'node:http';
+
+const BASE_URL = 'http://localhost:5000';
+const API_PATH = '/api/v1/rest';
+
+function request(method, path, body = null) {
+  return new Promise((resolve, reject) => {
+    const fullPath = API_PATH + path;
+    const options = {
+      hostname: 'localhost',
+      port: 5000,
+      path: fullPath,
+      method,
+      headers: { 'Content-Type': 'application/json' }
+    };
+
+    const req = http.request(options, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          resolve({ status: res.statusCode, data: JSON.parse(data) });
+        } catch {
+          resolve({ status: res.statusCode, data });
+        }
+      });
+    });
+    req.on('error', reject);
+    if (body) req.write(JSON.stringify(body));
+    req.end();
+  });
+}
+
+describe('Edge Case Tests', () => {
+  let testDealId;
+
+  before(async () => {
+    const res = await request('POST', '/deals', {
+      externalId: `edge-test-${Date.now()}`,
+      name: 'Edge Case Test Deal',
+      mode: 'DIRECT',
+      source: 'influence',
+      brand: 'Test Brand',
+      clientType: 'AGENCY',
+      currency: 'USD',
+      status: 'GENERATED',
+      approvalEmails: ['approver@test.com'],
+      marketSelection: { country: 'US', currency: 'USD' },
+      budgetSetup: { currency: 'USD', budgetAmount: 10000 },
+      campaignGoal: { type: 'IMPRESSIONS', targetValue: 1000000 }
+    });
+    assert.strictEqual(res.status, 201);
+    testDealId = res.data.result.dealId;
+  });
+
+  after(async () => {
+    if (testDealId) {
+      await request('DELETE', `/deals/${testDealId}`);
+    }
+  });
+
+  describe('Status Transition Edge Cases', () => {
+    it('should reject invalid transition GENERATED -> LIVE', async () => {
+      const { status, data } = await request('POST', `/deals/${testDealId}/status`, { status: 'LIVE' });
+      assert.strictEqual(status, 400);
+      assert.ok(data.code === 'INVALID_STATUS_TRANSITION' || data.message?.includes('Cannot transition'));
+    });
+
+    it('should allow GENERATED -> APPROVED', async () => {
+      const { status, data } = await request('POST', `/deals/${testDealId}/status`, { status: 'APPROVED' });
+      assert.strictEqual(status, 200, `Failed: ${JSON.stringify(data)}`);
+      assert.strictEqual(data.result.currentStatus, 'APPROVED');
+    });
+
+    it('should allow APPROVED -> REOPENED', async () => {
+      const { status, data } = await request('POST', `/deals/${testDealId}/reopen`, {});
+      assert.strictEqual(status, 200, `Failed: ${JSON.stringify(data)}`);
+      assert.strictEqual(data.result.currentStatus, 'REOPENED');
+    });
+
+    it('should allow REOPENED -> PENDING (via approval request)', async () => {
+      const { status, data } = await request('POST', `/deals/${testDealId}/approval/request`, {
+        frontendUrl: 'https://example.com/approve'
+      });
+      assert.strictEqual(status, 200, `Failed: ${JSON.stringify(data)}`);
+      assert.strictEqual(data.result.status, 'PENDING');
+    });
+
+    it('should reject reopen from PENDING status', async () => {
+      const { status, data } = await request('POST', `/deals/${testDealId}/reopen`, {});
+      assert.strictEqual(status, 400, `Expected 400 for PENDING->REOPEN: ${JSON.stringify(data)}`);
+      assert.strictEqual(data.code, 'CANNOT_REOPEN');
+    });
+  });
+
+  describe('Auto-Approval Edge Cases', () => {
+    let autoApproveDealId;
+
+    before(async () => {
+      const res = await request('POST', '/deals', {
+        externalId: `auto-approve-${Date.now()}`,
+        name: 'Auto Approve Test',
+        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 }
+      });
+      autoApproveDealId = res.data.result.dealId;
+    });
+
+    after(async () => {
+      if (autoApproveDealId) {
+        await request('DELETE', `/deals/${autoApproveDealId}`);
+      }
+    });
+
+    it('should auto-approve when no approvalEmails provided', async () => {
+      const { status, data } = await request('POST', `/deals/${autoApproveDealId}/approval/request`, {
+        approvalEmails: []
+      });
+      assert.strictEqual(status, 200, `Failed: ${JSON.stringify(data)}`);
+      assert.strictEqual(data.result.status, 'APPROVED');
+    });
+
+    it('should auto-approve when approvalEmails is undefined', async () => {
+      const res2 = await request('POST', '/deals', {
+        externalId: `auto-approve2-${Date.now()}`,
+        name: 'Auto Approve Test 2',
+        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 }
+      });
+      const dealId2 = res2.data.result.dealId;
+
+      const { status, data } = await request('POST', `/deals/${dealId2}/approval/request`, {});
+      assert.strictEqual(status, 200, `Failed: ${JSON.stringify(data)}`);
+      assert.strictEqual(data.result.status, 'APPROVED');
+
+      await request('DELETE', `/deals/${dealId2}`);
+    });
+  });
+
+  describe('Reopen Cascade Edge Cases', () => {
+    let cascadeDealId;
+
+    before(async () => {
+      const res = await request('POST', '/deals', {
+        externalId: `cascade-edge-${Date.now()}`,
+        name: 'Cascade Edge Test',
+        mode: 'DIRECT',
+        source: 'influence',
+        brand: 'Test Brand',
+        clientType: 'AGENCY',
+        currency: 'USD',
+        status: 'APPROVED',
+        marketSelection: { country: 'US', currency: 'USD' },
+        budgetSetup: { currency: 'USD', budgetAmount: 10000 },
+        campaignGoal: { type: 'IMPRESSIONS', targetValue: 1000000 }
+      });
+      cascadeDealId = res.data.result.dealId;
+    });
+
+    after(async () => {
+      if (cascadeDealId) {
+        await request('DELETE', `/deals/${cascadeDealId}`);
+      }
+    });
+
+    it('should cascade multiple line items to REOPENED', async () => {
+      await request('POST', `/deals/${cascadeDealId}/line-items`, {
+        externalId: `li1-${Date.now()}`,
+        name: 'Line Item 1',
+        duration: 15,
+        status: 'APPROVED'
+      });
+
+      await request('POST', `/deals/${cascadeDealId}/line-items`, {
+        externalId: `li2-${Date.now()}`,
+        name: 'Line Item 2',
+        duration: 15,
+        status: 'LIVE'
+      });
+
+      await request('POST', `/deals/${cascadeDealId}/line-items`, {
+        externalId: `li3-${Date.now()}`,
+        name: 'Line Item 3 (Archived)',
+        duration: 15,
+        status: 'ARCHIVED'
+      });
+
+      const { status, data } = await request('POST', `/deals/${cascadeDealId}/reopen`, {});
+      assert.strictEqual(status, 200, `Failed: ${JSON.stringify(data)}`);
+      assert.strictEqual(data.result.currentStatus, 'REOPENED');
+
+      const cascaded = data.result.cascadedLineItems || [];
+      const skipped = data.result.skippedLineItems || [];
+
+      assert.ok(cascaded.length >= 2, `Expected at least 2 cascaded, got ${cascaded.length}`);
+      cascaded.forEach(li => {
+        assert.strictEqual(li.currentStatus, 'REOPENED');
+      });
+
+      const archivedSkipped = skipped.find(li => li.reason.includes('Archived'));
+      assert.ok(archivedSkipped, 'Archived line item should be skipped');
+    });
+
+    it('should skip already REOPENED line items on second reopen', async () => {
+      await request('POST', `/deals/${cascadeDealId}/status`, { status: 'APPROVED' });
+
+      const { status, data } = await request('POST', `/deals/${cascadeDealId}/reopen`, {});
+      assert.strictEqual(status, 200);
+
+      const skipped = data.result.skippedLineItems || [];
+      const alreadyReopened = skipped.filter(li => li.reason && li.reason.includes('REOPENED'));
+      assert.ok(alreadyReopened.length > 0 || skipped.length > 0, `Should have skipped items: ${JSON.stringify(data.result)}`);
+    });
+  });
+
+  describe('Programmatic Mode Restrictions', () => {
+    let progDealId;
+
+    before(async () => {
+      const res = await request('POST', '/deals', {
+        externalId: `prog-edge-${Date.now()}`,
+        name: 'Programmatic Edge Test',
+        mode: 'PROGRAMMATIC',
+        source: 'broadsign',
+        brand: 'Test Brand',
+        clientType: 'AGENCY',
+        currency: 'USD',
+        status: 'GENERATED',
+        marketSelection: { country: 'US', currency: 'USD' },
+        budgetSetup: { currency: 'USD', budgetAmount: 10000 },
+        campaignGoal: { type: 'IMPRESSIONS', targetValue: 1000000 }
+      });
+      progDealId = res.data.result.dealId;
+    });
+
+    after(async () => {
+      if (progDealId) {
+        await request('DELETE', `/deals/${progDealId}`);
+      }
+    });
+
+    it('should reject reopen for PROGRAMMATIC deals', async () => {
+      await request('POST', `/deals/${progDealId}/status`, { status: 'APPROVED' });
+
+      const { status, data } = await request('POST', `/deals/${progDealId}/reopen`, {});
+      assert.strictEqual(status, 400);
+      assert.strictEqual(data.code, 'INVALID_MODE');
+    });
+  });
+
+  describe('Full Workflow Cycle', () => {
+    let cycleDealId;
+
+    it('should complete full DIRECT workflow: GENERATED -> APPROVED -> REOPENED -> APPROVED (auto)', async () => {
+      const createRes = await request('POST', '/deals', {
+        externalId: `cycle-${Date.now()}`,
+        name: 'Full Cycle Test',
+        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 }
+      });
+      assert.strictEqual(createRes.status, 201);
+      cycleDealId = createRes.data.result.dealId;
+
+      const approveRes = await request('POST', `/deals/${cycleDealId}/status`, { status: 'APPROVED' });
+      assert.strictEqual(approveRes.status, 200);
+      assert.strictEqual(approveRes.data.result.currentStatus, 'APPROVED');
+
+      const reopenRes = await request('POST', `/deals/${cycleDealId}/reopen`, { reason: 'Need changes' });
+      assert.strictEqual(reopenRes.status, 200);
+      assert.strictEqual(reopenRes.data.result.currentStatus, 'REOPENED');
+
+      const requestRes = await request('POST', `/deals/${cycleDealId}/approval/request`, {
+        approvalEmails: [],
+        frontendUrl: 'https://example.com'
+      });
+      assert.strictEqual(requestRes.status, 200, `Auto-approve failed: ${JSON.stringify(requestRes.data)}`);
+      assert.strictEqual(requestRes.data.result.status, 'APPROVED');
+
+      await request('DELETE', `/deals/${cycleDealId}`);
+    });
+
+    it('should complete full DIRECT workflow with approvers: GENERATED -> APPROVED -> REOPENED -> PENDING', async () => {
+      const createRes = await request('POST', '/deals', {
+        externalId: `cycle2-${Date.now()}`,
+        name: 'Full Cycle Test With Approvers',
+        mode: 'DIRECT',
+        source: 'influence',
+        brand: 'Test Brand',
+        clientType: 'AGENCY',
+        currency: 'USD',
+        status: 'GENERATED',
+        approvalEmails: ['approver@test.com'],
+        marketSelection: { country: 'US', currency: 'USD' },
+        budgetSetup: { currency: 'USD', budgetAmount: 10000 },
+        campaignGoal: { type: 'IMPRESSIONS', targetValue: 1000000 }
+      });
+      assert.strictEqual(createRes.status, 201);
+      const dealId = createRes.data.result.dealId;
+
+      const approveRes = await request('POST', `/deals/${dealId}/status`, { status: 'APPROVED' });
+      assert.strictEqual(approveRes.status, 200);
+      assert.strictEqual(approveRes.data.result.currentStatus, 'APPROVED');
+
+      const reopenRes = await request('POST', `/deals/${dealId}/reopen`, { reason: 'Need changes' });
+      assert.strictEqual(reopenRes.status, 200);
+      assert.strictEqual(reopenRes.data.result.currentStatus, 'REOPENED');
+
+      const requestRes = await request('POST', `/deals/${dealId}/approval/request`, {
+        frontendUrl: 'https://example.com'
+      });
+      assert.strictEqual(requestRes.status, 200, `Approval request failed: ${JSON.stringify(requestRes.data)}`);
+      assert.strictEqual(requestRes.data.result.status, 'PENDING');
+
+      await request('DELETE', `/deals/${dealId}`);
+    });
+  });
+});

package/PCM/tests/line-item-status.test.js

@@ -0,0 +1,340 @@
+import { describe, it, after } from 'node:test';
+import assert from 'node:assert';
+
+const BASE_URL = 'http://localhost:5000';
+
+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 };
+}
+
+describe('Line Item Status Workflow Tests', () => {
+  const createdDealIds = [];
+
+  after(async () => {
+    for (const dealId of createdDealIds) {
+      try {
+        await request('DELETE', `/api/v1/rest/deals/${dealId}`);
+      } catch (e) {}
+    }
+  });
+
+  describe('Line Item Status Transitions', () => {
+    it('should update line item status from GENERATED to APPROVED', async () => {
+      const dealRes = await request('POST', '/api/v1/rest/deals', {
+        externalId: `li-status-test-${Date.now()}`,
+        name: 'Line Item Status Test',
+        mode: 'DIRECT',
+        source: 'influence',
+        brand: 'Test Brand',
+        clientType: 'AGENCY',
+        currency: 'USD',
+        status: 'APPROVED',
+        marketSelection: { country: 'US', currency: 'USD' },
+        budgetSetup: { currency: 'USD', budgetAmount: 50000 },
+        campaignGoal: { type: 'IMPRESSIONS', targetValue: 1000000 }
+      });
+      
+      assert.strictEqual(dealRes.status, 201);
+      const dealId = dealRes.data.result.dealId;
+      createdDealIds.push(dealId);
+
+      const lineItemRes = await request('POST', `/api/v1/rest/deals/${dealId}/line-items`, {
+        externalId: `li-${Date.now()}`,
+        name: 'Test Line Item',
+        status: 'GENERATED'
+      });
+      
+      assert.strictEqual(lineItemRes.status, 201);
+      const lineItemId = lineItemRes.data.result.id;
+
+      const statusRes = await request('POST', `/api/v1/rest/deals/${dealId}/line-items/${lineItemId}/status`, {
+        status: 'APPROVED'
+      });
+
+      assert.strictEqual(statusRes.status, 200);
+      assert.strictEqual(statusRes.data.result.previousStatus, 'GENERATED');
+      assert.strictEqual(statusRes.data.result.currentStatus, 'APPROVED');
+    });
+
+    it('should reject invalid status transition', async () => {
+      const dealRes = await request('POST', '/api/v1/rest/deals', {
+        externalId: `li-invalid-trans-${Date.now()}`,
+        name: 'Invalid Transition Test',
+        mode: 'DIRECT',
+        source: 'influence',
+        brand: 'Test Brand',
+        clientType: 'AGENCY',
+        currency: 'USD',
+        status: 'APPROVED',
+        marketSelection: { country: 'US', currency: 'USD' },
+        budgetSetup: { currency: 'USD', budgetAmount: 50000 },
+        campaignGoal: { type: 'IMPRESSIONS', targetValue: 1000000 }
+      });
+      
+      const dealId = dealRes.data.result.dealId;
+      createdDealIds.push(dealId);
+
+      const lineItemRes = await request('POST', `/api/v1/rest/deals/${dealId}/line-items`, {
+        externalId: `li-invalid-${Date.now()}`,
+        name: 'Test Line Item',
+        status: 'GENERATED'
+      });
+      
+      const lineItemId = lineItemRes.data.result.id;
+
+      const statusRes = await request('POST', `/api/v1/rest/deals/${dealId}/line-items/${lineItemId}/status`, {
+        status: 'COMPLETED'
+      });
+
+      assert.strictEqual(statusRes.status, 400);
+      assert.strictEqual(statusRes.data.code, 'INVALID_STATUS_TRANSITION');
+    });
+
+    it('should reject line item status exceeding campaign status', async () => {
+      const dealRes = await request('POST', '/api/v1/rest/deals', {
+        externalId: `li-exceed-${Date.now()}`,
+        name: 'Exceed Campaign Status Test',
+        mode: 'DIRECT',
+        source: 'influence',
+        brand: 'Test Brand',
+        clientType: 'AGENCY',
+        currency: 'USD',
+        status: 'GENERATED',
+        marketSelection: { country: 'US', currency: 'USD' },
+        budgetSetup: { currency: 'USD', budgetAmount: 50000 },
+        campaignGoal: { type: 'IMPRESSIONS', targetValue: 1000000 }
+      });
+      
+      const dealId = dealRes.data.result.dealId;
+      createdDealIds.push(dealId);
+
+      const lineItemRes = await request('POST', `/api/v1/rest/deals/${dealId}/line-items`, {
+        externalId: `li-exceed-li-${Date.now()}`,
+        name: 'Test Line Item',
+        status: 'GENERATED'
+      });
+      
+      const lineItemId = lineItemRes.data.result.id;
+
+      const statusRes = await request('POST', `/api/v1/rest/deals/${dealId}/line-items/${lineItemId}/status`, {
+        status: 'APPROVED'
+      });
+
+      assert.strictEqual(statusRes.status, 400);
+      assert.strictEqual(statusRes.data.code, 'INVALID_STATUS_TRANSITION');
+      assert.ok(statusRes.data.errors.some(e => e.code === 'EXCEEDS_CAMPAIGN_STATUS'));
+    });
+  });
+
+  describe('Get Line Item Status Transitions', () => {
+    it('should return valid transitions for line item', async () => {
+      const dealRes = await request('POST', '/api/v1/rest/deals', {
+        externalId: `li-trans-info-${Date.now()}`,
+        name: 'Transitions Info Test',
+        mode: 'DIRECT',
+        source: 'influence',
+        brand: 'Test Brand',
+        clientType: 'AGENCY',
+        currency: 'USD',
+        status: 'APPROVED',
+        marketSelection: { country: 'US', currency: 'USD' },
+        budgetSetup: { currency: 'USD', budgetAmount: 50000 },
+        campaignGoal: { type: 'IMPRESSIONS', targetValue: 1000000 }
+      });
+      
+      const dealId = dealRes.data.result.dealId;
+      createdDealIds.push(dealId);
+
+      const lineItemRes = await request('POST', `/api/v1/rest/deals/${dealId}/line-items`, {
+        externalId: `li-trans-${Date.now()}`,
+        name: 'Test Line Item',
+        status: 'GENERATED'
+      });
+      
+      const lineItemId = lineItemRes.data.result.id;
+
+      const transRes = await request('GET', `/api/v1/rest/deals/${dealId}/line-items/${lineItemId}/status/transitions`);
+
+      assert.strictEqual(transRes.status, 200);
+      assert.strictEqual(transRes.data.result.currentStatus, 'GENERATED');
+      assert.ok(Array.isArray(transRes.data.result.validTransitions));
+      assert.ok(transRes.data.result.validTransitions.includes('APPROVED'));
+      assert.ok(transRes.data.result.editableFields);
+    });
+  });
+
+  describe('Status Definitions Endpoint', () => {
+    it('should return all line item status definitions', async () => {
+      const dealRes = await request('POST', '/api/v1/rest/deals', {
+        externalId: `li-def-${Date.now()}`,
+        name: 'Definitions Test',
+        mode: 'DIRECT',
+        source: 'influence',
+        brand: 'Test Brand',
+        clientType: 'AGENCY',
+        currency: 'USD',
+        status: 'GENERATED',
+        marketSelection: { country: 'US', currency: 'USD' },
+        budgetSetup: { currency: 'USD', budgetAmount: 50000 },
+        campaignGoal: { type: 'IMPRESSIONS', targetValue: 1000000 }
+      });
+      
+      const dealId = dealRes.data.result.dealId;
+      createdDealIds.push(dealId);
+
+      const defRes = await request('GET', `/api/v1/rest/deals/${dealId}/line-items/status/definitions`);
+
+      assert.strictEqual(defRes.status, 200);
+      assert.ok(defRes.data.result.statuses);
+      assert.ok(defRes.data.result.definitions);
+      assert.ok(defRes.data.result.transitionOwnership);
+      assert.ok(defRes.data.result.statuses.APPROVED);
+      assert.ok(defRes.data.result.statuses.LIVE);
+    });
+  });
+
+  describe('Campaign Status Cascade to Line Items', () => {
+    it('should cascade campaign status to line items when campaign status changes', async () => {
+      const dealRes = await request('POST', '/api/v1/rest/deals', {
+        externalId: `cascade-test-${Date.now()}`,
+        name: 'Cascade Status Test',
+        mode: 'DIRECT',
+        source: 'influence',
+        brand: 'Test Brand',
+        clientType: 'AGENCY',
+        currency: 'USD',
+        status: 'GENERATED',
+        marketSelection: { country: 'US', currency: 'USD' },
+        budgetSetup: { currency: 'USD', budgetAmount: 50000 },
+        campaignGoal: { type: 'IMPRESSIONS', targetValue: 1000000 }
+      });
+      
+      assert.strictEqual(dealRes.status, 201);
+      const dealId = dealRes.data.result.dealId;
+      createdDealIds.push(dealId);
+
+      await request('POST', `/api/v1/rest/deals/${dealId}/line-items`, {
+        externalId: `cascade-li-1-${Date.now()}`,
+        name: 'Line Item 1',
+        status: 'GENERATED'
+      });
+
+      await request('POST', `/api/v1/rest/deals/${dealId}/line-items`, {
+        externalId: `cascade-li-2-${Date.now()}`,
+        name: 'Line Item 2',
+        status: 'GENERATED'
+      });
+
+      const statusRes = await request('POST', `/api/v1/rest/deals/${dealId}/status`, {
+        status: 'APPROVED'
+      });
+
+      assert.strictEqual(statusRes.status, 200);
+      assert.strictEqual(statusRes.data.result.currentStatus, 'APPROVED');
+      
+      if (statusRes.data.result.cascadedLineItems) {
+        assert.ok(statusRes.data.result.cascadedLineItems.length > 0);
+        for (const li of statusRes.data.result.cascadedLineItems) {
+          assert.strictEqual(li.currentStatus, 'APPROVED');
+        }
+      }
+    });
+
+    it('should skip archived line items during cascade', async () => {
+      const dealRes = await request('POST', '/api/v1/rest/deals', {
+        externalId: `cascade-archived-${Date.now()}`,
+        name: 'Cascade Archived Test',
+        mode: 'DIRECT',
+        source: 'influence',
+        brand: 'Test Brand',
+        clientType: 'AGENCY',
+        currency: 'USD',
+        status: 'GENERATED',
+        marketSelection: { country: 'US', currency: 'USD' },
+        budgetSetup: { currency: 'USD', budgetAmount: 50000 },
+        campaignGoal: { type: 'IMPRESSIONS', targetValue: 1000000 }
+      });
+      
+      const dealId = dealRes.data.result.dealId;
+      createdDealIds.push(dealId);
+
+      const li1Res = await request('POST', `/api/v1/rest/deals/${dealId}/line-items`, {
+        externalId: `cascade-archived-li-${Date.now()}`,
+        name: 'Active Line Item',
+        status: 'GENERATED'
+      });
+
+      const li2Res = await request('POST', `/api/v1/rest/deals/${dealId}/line-items`, {
+        externalId: `cascade-archived-li2-${Date.now()}`,
+        name: 'Archived Line Item',
+        status: 'ARCHIVED'
+      });
+
+      const statusRes = await request('POST', `/api/v1/rest/deals/${dealId}/status`, {
+        status: 'APPROVED'
+      });
+
+      assert.strictEqual(statusRes.status, 200);
+      
+      if (statusRes.data.result.skippedLineItems) {
+        assert.ok(statusRes.data.result.skippedLineItems.some(li => 
+          li.reason.includes('Archived')
+        ));
+      }
+      
+      if (statusRes.data.result.cascadedLineItems) {
+        assert.ok(!statusRes.data.result.cascadedLineItems.some(li => 
+          li.externalId === li2Res.data.result.externalId
+        ));
+      }
+    });
+
+    it('should skip line items with invalid transitions during cascade', async () => {
+      const dealRes = await request('POST', '/api/v1/rest/deals', {
+        externalId: `cascade-invalid-${Date.now()}`,
+        name: 'Cascade Invalid Test',
+        mode: 'DIRECT',
+        source: 'influence',
+        brand: 'Test Brand',
+        clientType: 'AGENCY',
+        currency: 'USD',
+        status: 'GENERATED',
+        marketSelection: { country: 'US', currency: 'USD' },
+        budgetSetup: { currency: 'USD', budgetAmount: 50000 },
+        campaignGoal: { type: 'IMPRESSIONS', targetValue: 1000000 }
+      });
+      
+      const dealId = dealRes.data.result.dealId;
+      createdDealIds.push(dealId);
+
+      await request('POST', `/api/v1/rest/deals/${dealId}/line-items`, {
+        externalId: `cascade-valid-li-${Date.now()}`,
+        name: 'Valid Line Item',
+        status: 'GENERATED'
+      });
+
+      await request('POST', `/api/v1/rest/deals/${dealId}/line-items`, {
+        externalId: `cascade-draft-li-${Date.now()}`,
+        name: 'Draft Line Item',
+        status: 'DRAFT'
+      });
+
+      const statusRes = await request('POST', `/api/v1/rest/deals/${dealId}/status`, {
+        status: 'APPROVED'
+      });
+
+      assert.strictEqual(statusRes.status, 200);
+      
+      if (statusRes.data.result.skippedLineItems) {
+        assert.ok(statusRes.data.result.skippedLineItems.length > 0);
+      }
+    });
+  });
+});