/**
 * Tests pour l'API route /api/track
 */

describe('Track API Route', () => {
  describe('Payload Validation', () => {
    interface TrackPayload {
      method: string;
      path: string;
      statusCode: number;
      durationMs: number;
    }

    const validatePayload = (body: Partial<TrackPayload>): boolean => {
      const { method, path, statusCode, durationMs } = body;
      return !!(method && path && statusCode !== undefined && durationMs !== undefined);
    };

    it('should accept valid payload', () => {
      const payload: TrackPayload = {
        method: 'GET',
        path: '/api/test',
        statusCode: 200,
        durationMs: 50,
      };
      expect(validatePayload(payload)).toBe(true);
    });

    it('should reject payload without method', () => {
      const payload = {
        path: '/api/test',
        statusCode: 200,
        durationMs: 50,
      };
      expect(validatePayload(payload)).toBe(false);
    });

    it('should reject payload without path', () => {
      const payload = {
        method: 'GET',
        statusCode: 200,
        durationMs: 50,
      };
      expect(validatePayload(payload)).toBe(false);
    });

    it('should reject payload without statusCode', () => {
      const payload = {
        method: 'GET',
        path: '/api/test',
        durationMs: 50,
      };
      expect(validatePayload(payload)).toBe(false);
    });

    it('should reject payload without durationMs', () => {
      const payload = {
        method: 'GET',
        path: '/api/test',
        statusCode: 200,
      };
      expect(validatePayload(payload)).toBe(false);
    });

    it('should accept statusCode 0', () => {
      const payload = {
        method: 'GET',
        path: '/api/test',
        statusCode: 0,
        durationMs: 50,
      };
      expect(validatePayload(payload)).toBe(true);
    });

    it('should accept durationMs 0', () => {
      const payload = {
        method: 'GET',
        path: '/api/test',
        statusCode: 200,
        durationMs: 0,
      };
      expect(validatePayload(payload)).toBe(true);
    });
  });

  describe('HTTP Methods', () => {
    const validMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS', 'HEAD'];

    validMethods.forEach((method) => {
      it(`should accept ${method} method`, () => {
        expect(validMethods).toContain(method);
      });
    });
  });

  describe('Status Codes', () => {
    it('should accept 2xx status codes', () => {
      const successCodes = [200, 201, 204];
      successCodes.forEach((code) => {
        expect(code).toBeGreaterThanOrEqual(200);
        expect(code).toBeLessThan(300);
      });
    });

    it('should accept 4xx status codes', () => {
      const clientErrorCodes = [400, 401, 403, 404];
      clientErrorCodes.forEach((code) => {
        expect(code).toBeGreaterThanOrEqual(400);
        expect(code).toBeLessThan(500);
      });
    });

    it('should accept 5xx status codes', () => {
      const serverErrorCodes = [500, 502, 503];
      serverErrorCodes.forEach((code) => {
        expect(code).toBeGreaterThanOrEqual(500);
        expect(code).toBeLessThan(600);
      });
    });
  });
});