adserver-dashboard 1.0.0

package/PCM/tests/campaign-status.test.js

@@ -0,0 +1,539 @@
+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 };
+}
+
+let testDealId;
+let testDealInternalId;
+
+describe('Campaign Status Workflow Tests', () => {
+  before(async () => {
+    const { status, data } = await request('POST', '/deals', {
+      externalId: `status-test-${Date.now()}`,
+      name: 'Status Workflow Test Deal',
+      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(status, 201, `Failed to create deal: ${JSON.stringify(data)}`);
+    testDealId = data.result.dealId;
+    testDealInternalId = data.result.id;
+  });
+
+  after(async () => {
+    if (testDealId) {
+      await request('DELETE', `/deals/${testDealId}`);
+    }
+  });
+
+  describe('Status Definitions Endpoint', () => {
+    it('should return all status definitions for DIRECT workflow', async () => {
+      const { status, data } = await request('GET', '/deals/status/definitions?workflow=DIRECT');
+      assert.strictEqual(status, 200);
+      assert.ok(data.result.statuses);
+      assert.ok(data.result.definitions);
+      assert.ok(data.result.transitionOwnership);
+      assert.ok(data.result.workflowRules);
+      assert.strictEqual(data.result.workflow, 'DIRECT');
+      assert.ok(data.result.definitions.GENERATED);
+      assert.ok(data.result.definitions.APPROVED);
+      assert.ok(data.result.definitions.LIVE);
+    });
+
+    it('should return all status definitions for PROGRAMMATIC workflow', async () => {
+      const { status, data } = await request('GET', '/deals/status/definitions?workflow=PROGRAMMATIC');
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.workflow, 'PROGRAMMATIC');
+      assert.ok(data.result.definitions.PENDING.includes('DSP'));
+    });
+
+    it('should return workflow rules including sameDayApproval', async () => {
+      const { status, data } = await request('GET', '/deals/status/definitions');
+      assert.strictEqual(status, 200);
+      assert.ok(data.result.workflowRules.sameDayApproval);
+      assert.ok(data.result.workflowRules.externalSource);
+      assert.ok(Array.isArray(data.result.workflowRules.sameDayApproval.rules));
+    });
+  });
+
+  describe('Status Transitions Endpoint', () => {
+    it('should return valid transitions for a deal', async () => {
+      const { status, data } = await request('GET', `/deals/${testDealId}/status/transitions`);
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.dealId, testDealId);
+      assert.strictEqual(data.result.currentStatus, 'GENERATED');
+      assert.ok(Array.isArray(data.result.validTransitions));
+      assert.ok(data.result.validTransitions.includes('PENDING'));
+      assert.ok(data.result.validTransitions.includes('APPROVED'));
+    });
+
+    it('should return editable fields based on status', async () => {
+      const { status, data } = await request('GET', `/deals/${testDealId}/status/transitions`);
+      assert.strictEqual(status, 200);
+      assert.ok(data.result.editableFields);
+      assert.strictEqual(data.result.editableFields.pacing, true);
+      assert.strictEqual(data.result.editableFields.budget, true);
+      assert.strictEqual(data.result.editableFields.structure, true);
+    });
+
+    it('should return 404 for non-existent deal', async () => {
+      const { status, data } = await request('GET', '/deals/non-existent-deal/status/transitions');
+      assert.strictEqual(status, 404);
+      assert.strictEqual(data.code, 'NOT_FOUND');
+    });
+  });
+
+  describe('Status Transition - Valid Transitions', () => {
+    it('should transition from GENERATED to PENDING', async () => {
+      const { status, data } = await request('POST', `/deals/${testDealId}/status`, {
+        status: 'PENDING',
+        reason: 'IO sent to client'
+      });
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.previousStatus, 'GENERATED');
+      assert.strictEqual(data.result.currentStatus, 'PENDING');
+    });
+
+    it('should transition from PENDING to APPROVED', async () => {
+      const { status, data } = await request('POST', `/deals/${testDealId}/status`, {
+        status: 'APPROVED',
+        owner: 'USER',
+        reason: 'Signed IO received'
+      });
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.previousStatus, 'PENDING');
+      assert.strictEqual(data.result.currentStatus, 'APPROVED');
+    });
+
+    it('should transition from APPROVED to LIVE (by MQ_WORKER)', async () => {
+      const { status, data } = await request('POST', `/deals/${testDealId}/status`, {
+        status: 'LIVE',
+        owner: 'MQ_WORKER',
+        reason: 'First ad play confirmed'
+      });
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.previousStatus, 'APPROVED');
+      assert.strictEqual(data.result.currentStatus, 'LIVE');
+    });
+
+    it('should transition from LIVE to COMPLETED (by SCHEDULER)', async () => {
+      const { status, data } = await request('POST', `/deals/${testDealId}/status`, {
+        status: 'COMPLETED',
+        owner: 'SCHEDULER',
+        reason: 'Campaign end date reached'
+      });
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.previousStatus, 'LIVE');
+      assert.strictEqual(data.result.currentStatus, 'COMPLETED');
+    });
+
+    it('should allow REOPENED from COMPLETED', async () => {
+      const { status, data } = await request('POST', `/deals/${testDealId}/status`, {
+        status: 'REOPENED',
+        owner: 'ADMIN',
+        reason: 'Client requested extension'
+      });
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.previousStatus, 'COMPLETED');
+      assert.strictEqual(data.result.currentStatus, 'REOPENED');
+    });
+  });
+
+  describe('Status Transition - Invalid Transitions', () => {
+    let invalidTestDealId;
+
+    before(async () => {
+      const { status, data } = await request('POST', '/deals', {
+        externalId: `invalid-status-test-${Date.now()}`,
+        name: 'Invalid Status Test Deal',
+        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(status, 201, `Failed: ${JSON.stringify(data)}`);
+      invalidTestDealId = data.result.dealId;
+    });
+
+    after(async () => {
+      if (invalidTestDealId) {
+        await request('DELETE', `/deals/${invalidTestDealId}`);
+      }
+    });
+
+    it('should reject invalid status value', async () => {
+      const { status, data } = await request('POST', `/deals/${invalidTestDealId}/status`, {
+        status: 'INVALID_STATUS'
+      });
+      assert.strictEqual(status, 400);
+      assert.strictEqual(data.code, 'VALIDATION_ERROR');
+    });
+
+    it('should reject LIVE transition from GENERATED (skipping states)', async () => {
+      const { status, data } = await request('POST', `/deals/${invalidTestDealId}/status`, {
+        status: 'LIVE',
+        owner: 'MQ_WORKER'
+      });
+      assert.strictEqual(status, 400);
+      assert.strictEqual(data.code, 'INVALID_STATUS_TRANSITION');
+      assert.ok(data.allowedTransitions);
+    });
+
+    it('should reject USER setting LIVE status directly', async () => {
+      await request('POST', `/deals/${invalidTestDealId}/status`, { status: 'APPROVED' });
+      
+      const { status, data } = await request('POST', `/deals/${invalidTestDealId}/status`, {
+        status: 'LIVE',
+        owner: 'USER'
+      });
+      assert.strictEqual(status, 400);
+      assert.strictEqual(data.code, 'INVALID_STATUS_TRANSITION');
+      assert.ok(data.errors.some(e => e.code === 'LIVE_REQUIRES_DELIVERY'));
+    });
+
+    it('should reject ADMIN setting LIVE status (only MQ_WORKER allowed)', async () => {
+      const { status, data } = await request('POST', `/deals/${invalidTestDealId}/status`, {
+        status: 'LIVE',
+        owner: 'ADMIN'
+      });
+      assert.strictEqual(status, 400);
+      assert.strictEqual(data.code, 'INVALID_STATUS_TRANSITION');
+      assert.ok(data.errors.some(e => e.code === 'LIVE_REQUIRES_DELIVERY'));
+    });
+
+    it('should reject USER setting COMPLETED status', async () => {
+      await request('POST', `/deals/${invalidTestDealId}/status`, { status: 'LIVE', owner: 'MQ_WORKER' });
+      
+      const { status, data } = await request('POST', `/deals/${invalidTestDealId}/status`, {
+        status: 'COMPLETED',
+        owner: 'USER'
+      });
+      assert.strictEqual(status, 400);
+      assert.strictEqual(data.code, 'INVALID_STATUS_TRANSITION');
+      assert.ok(data.errors.some(e => e.code === 'SCHEDULER_ONLY'));
+    });
+
+    it('should reject ADMIN setting COMPLETED status (only SCHEDULER allowed)', async () => {
+      const { status, data } = await request('POST', `/deals/${invalidTestDealId}/status`, {
+        status: 'COMPLETED',
+        owner: 'ADMIN'
+      });
+      assert.strictEqual(status, 400);
+      assert.strictEqual(data.code, 'INVALID_STATUS_TRANSITION');
+      assert.ok(data.errors.some(e => e.code === 'SCHEDULER_ONLY'));
+    });
+  });
+
+  describe('Editable Fields Based on Status', () => {
+    let editTestDealId;
+
+    before(async () => {
+      const { status, data } = await request('POST', '/deals', {
+        externalId: `edit-test-${Date.now()}`,
+        name: 'Edit Test Deal',
+        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(status, 201, `Failed: ${JSON.stringify(data)}`);
+      editTestDealId = data.result.dealId;
+    });
+
+    after(async () => {
+      if (editTestDealId) {
+        await request('DELETE', `/deals/${editTestDealId}`);
+      }
+    });
+
+    it('should allow all edits in GENERATED status', async () => {
+      const { status, data } = await request('GET', `/deals/${editTestDealId}/status/transitions`);
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.editableFields.pacing, true);
+      assert.strictEqual(data.result.editableFields.budget, true);
+      assert.strictEqual(data.result.editableFields.structure, true);
+    });
+
+    it('should restrict structure edits in APPROVED status', async () => {
+      await request('POST', `/deals/${editTestDealId}/status`, { status: 'APPROVED' });
+      
+      const { status, data } = await request('GET', `/deals/${editTestDealId}/status/transitions`);
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.editableFields.pacing, true);
+      assert.strictEqual(data.result.editableFields.budget, true);
+      assert.strictEqual(data.result.editableFields.structure, false);
+    });
+
+    it('should only allow pacing in LIVE status', async () => {
+      await request('POST', `/deals/${editTestDealId}/status`, { status: 'LIVE', owner: 'MQ_WORKER' });
+      
+      const { status, data } = await request('GET', `/deals/${editTestDealId}/status/transitions`);
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.editableFields.pacing, true);
+      assert.strictEqual(data.result.editableFields.budget, false);
+      assert.strictEqual(data.result.editableFields.structure, false);
+    });
+  });
+
+  describe('External Source Restrictions', () => {
+    let externalDealId;
+
+    before(async () => {
+      const { status, data } = await request('POST', '/deals', {
+        externalId: `external-test-${Date.now()}`,
+        name: 'External Source Test Deal',
+        mode: 'DIRECT',
+        source: 'external-platform',
+        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(status, 201, `Failed: ${JSON.stringify(data)}`);
+      externalDealId = data.result.dealId;
+    });
+
+    after(async () => {
+      if (externalDealId) {
+        await request('DELETE', `/deals/${externalDealId}`);
+      }
+    });
+
+    it('should identify external source correctly', async () => {
+      const { status, data } = await request('GET', `/deals/${externalDealId}/status/transitions`);
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.source, 'EXTERNAL');
+    });
+
+    it('should restrict structure edits for external source even in GENERATED', async () => {
+      const { status, data } = await request('GET', `/deals/${externalDealId}/status/transitions`);
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.editableFields.structure, false);
+    });
+
+    it('should allow pacing edits in APPROVED for external source', async () => {
+      await request('POST', `/deals/${externalDealId}/status`, { status: 'APPROVED' });
+      
+      const { status, data } = await request('GET', `/deals/${externalDealId}/status/transitions`);
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.editableFields.pacing, true);
+      assert.strictEqual(data.result.editableFields.budget, true);
+    });
+  });
+
+  describe('Reopen Endpoint', () => {
+    let reopenDealId;
+    let reopenLineItemId;
+
+    before(async () => {
+      const { status, data } = await request('POST', '/deals', {
+        externalId: `reopen-test-${Date.now()}`,
+        name: 'Reopen Test Deal',
+        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(status, 201, `Failed: ${JSON.stringify(data)}`);
+      reopenDealId = data.result.dealId;
+
+      const liRes = await request('POST', `/deals/${reopenDealId}/line-items`, {
+        externalId: `reopen-li-${Date.now()}`,
+        name: 'Reopen Test Line Item',
+        duration: 15,
+        status: 'PENDING'
+      });
+      assert.strictEqual(liRes.status, 201, `Failed to create line item: ${JSON.stringify(liRes.data)}`);
+      reopenLineItemId = liRes.data.result.id;
+    });
+
+    after(async () => {
+      if (reopenDealId) {
+        await request('DELETE', `/deals/${reopenDealId}`);
+      }
+    });
+
+    it('should reject reopen for PROGRAMMATIC deals', async () => {
+      const progRes = await request('POST', '/deals', {
+        externalId: `prog-reopen-${Date.now()}`,
+        name: 'Programmatic Deal',
+        mode: 'PROGRAMMATIC',
+        brand: 'Test Brand',
+        clientType: 'AGENCY',
+        currency: 'USD',
+        status: 'GENERATED'
+      });
+      assert.strictEqual(progRes.status, 201, `Failed to create: ${JSON.stringify(progRes.data)}`);
+      const progDealId = progRes.data.result.dealId;
+
+      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');
+
+      await request('DELETE', `/deals/${progDealId}`);
+    });
+
+    it('should reject reopen from GENERATED status', async () => {
+      const { status, data } = await request('POST', `/deals/${reopenDealId}/reopen`, {});
+      assert.strictEqual(status, 400);
+      assert.strictEqual(data.code, 'CANNOT_REOPEN');
+    });
+
+    it('should reopen from APPROVED status', async () => {
+      await request('POST', `/deals/${reopenDealId}/status`, { status: 'APPROVED' });
+
+      const { status, data } = await request('POST', `/deals/${reopenDealId}/reopen`, {
+        reason: 'Need to update line items'
+      });
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.previousStatus, 'APPROVED');
+      assert.strictEqual(data.result.currentStatus, 'REOPENED');
+      assert.strictEqual(data.result.reason, 'Need to update line items');
+    });
+
+    it('should cascade line items to REOPENED on reopen', async () => {
+      const cascadeRes = await request('POST', '/deals', {
+        externalId: `cascade-test-${Date.now()}`,
+        name: 'Cascade Test Deal',
+        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 }
+      });
+      assert.strictEqual(cascadeRes.status, 201, `Failed: ${JSON.stringify(cascadeRes.data)}`);
+      const cascadeDealId = cascadeRes.data.result.dealId;
+
+      const liRes = await request('POST', `/deals/${cascadeDealId}/line-items`, {
+        externalId: `cascade-li-${Date.now()}`,
+        name: 'Cascade Line Item',
+        duration: 15,
+        status: 'APPROVED'
+      });
+      assert.strictEqual(liRes.status, 201, `Failed: ${JSON.stringify(liRes.data)}`);
+
+      const { status, data } = await request('POST', `/deals/${cascadeDealId}/reopen`, {});
+      assert.strictEqual(status, 200, `Reopen failed: ${JSON.stringify(data)}`);
+      assert.ok(data.result.cascadedLineItems, `No cascaded items: ${JSON.stringify(data.result)}`);
+      assert.ok(data.result.cascadedLineItems.length > 0);
+      assert.strictEqual(data.result.cascadedLineItems[0].currentStatus, 'REOPENED');
+
+      await request('DELETE', `/deals/${cascadeDealId}`);
+    });
+
+    it('should skip archived line items on reopen', async () => {
+      await request('POST', `/deals/${reopenDealId}/status`, { status: 'APPROVED' });
+
+      const archivedLiRes = await request('POST', `/deals/${reopenDealId}/line-items`, {
+        externalId: `archived-li-${Date.now()}`,
+        name: 'Archived Line Item',
+        duration: 15,
+        status: 'ARCHIVED'
+      });
+      const archivedLiId = archivedLiRes.data.result.id;
+
+      const { status, data } = await request('POST', `/deals/${reopenDealId}/reopen`, {});
+      assert.strictEqual(status, 200);
+
+      if (data.result.skippedLineItems) {
+        const skipped = data.result.skippedLineItems.find(li => li.lineItemId === archivedLiId);
+        if (skipped) {
+          assert.ok(skipped.reason.includes('Archived'));
+        }
+      }
+    });
+
+    it('should reopen from REJECTED status', async () => {
+      const rejRes = await request('POST', '/deals', {
+        externalId: `rejected-test-${Date.now()}`,
+        name: 'Rejected Deal',
+        mode: 'DIRECT',
+        source: 'influence',
+        brand: 'Test Brand',
+        clientType: 'AGENCY',
+        currency: 'USD',
+        status: 'REJECTED',
+        marketSelection: { country: 'US', currency: 'USD' },
+        budgetSetup: { currency: 'USD', budgetAmount: 10000 },
+        campaignGoal: { type: 'IMPRESSIONS', targetValue: 1000000 }
+      });
+      assert.strictEqual(rejRes.status, 201, `Failed: ${JSON.stringify(rejRes.data)}`);
+      const rejDealId = rejRes.data.result.dealId;
+
+      const { status, data } = await request('POST', `/deals/${rejDealId}/reopen`, {});
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.previousStatus, 'REJECTED');
+      assert.strictEqual(data.result.currentStatus, 'REOPENED');
+
+      await request('DELETE', `/deals/${rejDealId}`);
+    });
+
+    it('should reopen from ARCHIVED status', async () => {
+      const archRes = await request('POST', '/deals', {
+        externalId: `archived-test-${Date.now()}`,
+        name: 'Archived Deal',
+        mode: 'DIRECT',
+        source: 'influence',
+        brand: 'Test Brand',
+        clientType: 'AGENCY',
+        currency: 'USD',
+        status: 'ARCHIVED',
+        marketSelection: { country: 'US', currency: 'USD' },
+        budgetSetup: { currency: 'USD', budgetAmount: 10000 },
+        campaignGoal: { type: 'IMPRESSIONS', targetValue: 1000000 }
+      });
+      assert.strictEqual(archRes.status, 201, `Failed: ${JSON.stringify(archRes.data)}`);
+      const archDealId = archRes.data.result.dealId;
+
+      const { status, data } = await request('POST', `/deals/${archDealId}/reopen`, {});
+      assert.strictEqual(status, 200);
+      assert.strictEqual(data.result.previousStatus, 'ARCHIVED');
+      assert.strictEqual(data.result.currentStatus, 'REOPENED');
+
+      await request('DELETE', `/deals/${archDealId}`);
+    });
+  });
+});