Testing & Debugging: TDD, Automation & Profiling

// ❌ UNTESTABLE: Tightly coupled to global DB, system time, and external email API
import db from './db';
import sendGrid from '@sendgrid/mail';

export async function processRenewalBad(userId) {
  const user = await db.query('SELECT * FROM users WHERE id = $1', [userId]);
  if (new Date() > user.expiresAt) {
    await sendGrid.send({ to: user.email, subject: 'Expired' });
    return false;
  }
  return true;
}

// ✅ TESTABLE: Business logic extracted as pure function via Dependency Injection
export function isSubscriptionExpired(currentDate, expirationDate) {
  return currentDate.getTime() > expirationDate.getTime();
}

// Service orchestrator accepts injected dependencies (Notifier & Repository)
export async function processRenewalClean(userId, { userRepo, emailNotifier, clock = () => new Date() }) {
  const user = await userRepo.findById(userId);
  if (!user) throw new Error('User not found');

  if (isSubscriptionExpired(clock(), user.expiresAt)) {
    await emailNotifier.sendExpirationNotice(user.email);
    return { renewed: false, reason: 'expired' };
  }
  return { renewed: true };
}

import { calculateClusterHealth, sanitizeNodePayload } from './telemetry';

describe('Telemetry Metric Aggregation Engine', () => {
  
  describe('calculateClusterHealth()', () => {
    test('should return "healthy" when all nodes have latency < 50ms', () => {
      const mockNodes = [{ latency: 12 }, { latency: 34 }, { latency: 45 }];
      const result = calculateClusterHealth(mockNodes);
      expect(result.status).toBe('healthy');
      expect(result.averageLatency).toBeCloseTo(30.33, 1);
    });

    test('should return "critical" if any node is offline or latency > 100ms', () => {
      const mockNodes = [{ latency: 15 }, { latency: 140 }];
      const result = calculateClusterHealth(mockNodes);
      expect(result.status).toBe('critical');
    });

    test('should throw an error when passed an empty node array', () => {
      expect(() => {
        calculateClusterHealth([]);
      }).toThrow('Empty cluster dataset');
    });
  });

  describe('sanitizeNodePayload()', () => {
    test('should trim strings and strip unauthorized keys', () => {
      const rawInput = { name: '  node-alpha  ', secretAdminKey: 'hack' };
      const cleaned = sanitizeNodePayload(rawInput);
      
      expect(cleaned).toEqual({ name: 'node-alpha' });
      expect(cleaned).not.toHaveProperty('secretAdminKey');
    });
  });

});

import request from 'supertest';
import app from '../src/app'; // Express app instance (without app.listen!)

describe('POST /api/v1/nodes Integration', () => {

  test('should reject unauthenticated requests with 401 Unauthorized', async () => {
    const res = await request(app)
      .post('/api/v1/nodes')
      .send({ name: 'us-east-1' });

    expect(res.status).toBe(401);
    expect(res.body).toHaveProperty('error', 'Unauthorized');
  });

  test('should successfully provision a node when valid JWT is supplied', async () => {
    const validToken = 'mock.jwt.token';

    const res = await request(app)
      .post('/api/v1/nodes')
      .set('Authorization', `Bearer ${validToken}`)
      .send({ name: 'us-east-core', throughput: 14200 });

    expect(res.status).toBe(201);
    expect(res.headers['content-type']).toMatch(/json/);
    expect(res.body.node).toMatchObject({
      name: 'us-east-core',
      throughput: 14200
    });
  });

});

{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "node",
      "request": "launch",
      "name": "Debug Express Backend",
      "program": "${workspaceFolder}/src/server.js",
      "restart": true,
      "console": "integratedTerminal",
      "internalConsoleOptions": "neverOpen",
      "envFile": "${workspaceFolder}/.env"
    }
  ]
}

// --- 1. Production Business Logic (Tested via TDD) ---
class TelemetryAggregator {
  constructor(alertNotifier) {
    this.notifier = alertNotifier; // Injected dependency
  }

  computeMetrics(packets) {
    if (!packets || packets.length === 0) {
      return { averageThroughput: 0, healthyNodeCount: 0 };
    }

    let totalThroughput = 0;
    let healthyNodes = 0;

    for (const p of packets) {
      totalThroughput += p.throughput;
      if (p.errorRate < 0.05) {
        healthyNodes++;
      } else {
        this.notifier.notifySpike(p.nodeId, p.errorRate);
      }
    }

    return {
      averageThroughput: Math.round(totalThroughput / packets.length),
      healthyNodeCount: healthyNodes
    };
  }
}

// --- 2. Jest Test Suite with Mocks ---
describe('TelemetryAggregator (TDD Capstone)', () => {
  let mockNotifier;
  let aggregator;

  beforeEach(() => {
    // Create mock spy for external alert notifier
    mockNotifier = {
      notifySpike: jest.fn()
    };
    aggregator = new TelemetryAggregator(mockNotifier);
  });

  test('should calculate correct averages and healthy node counts', () => {
    const mockPackets = [
      { nodeId: 'n1', throughput: 100, errorRate: 0.01 },
      { nodeId: 'n2', throughput: 200, errorRate: 0.02 }
    ];

    const summary = aggregator.computeMetrics(mockPackets);

    expect(summary.averageThroughput).toBe(150);
    expect(summary.healthyNodeCount).toBe(2);
    expect(mockNotifier.notifySpike).not.toHaveBeenCalled();
  });

  test('should trigger alert notifier when error rate exceeds threshold', () => {
    const mockPackets = [
      { nodeId: 'bad-node', throughput: 50, errorRate: 0.12 }
    ];

    aggregator.computeMetrics(mockPackets);

    expect(mockNotifier.notifySpike).toHaveBeenCalledTimes(1);
    expect(mockNotifier.notifySpike).toHaveBeenCalledWith('bad-node', 0.12);
  });

  test('should handle empty packet streams defensively', () => {
    const summary = aggregator.computeMetrics([]);
    expect(summary.averageThroughput).toBe(0);
  });
});