gsmlg-dev/code-agent/agent-tester

// Code to test: auth.js middleware
const authenticate = async (req, res, next) => {
  // ... (from Implementer example)
};

// tests/middleware/auth.test.js
const request = require('supertest');
const jwt = require('jsonwebtoken');
const app = require('../../app');
const User = require('../../models/User');
// Mock dependencies
jest.mock('../../models/User');
jest.mock('jsonwebtoken');
describe('Authentication Middleware', () => {
  beforeEach(() => {
    jest.clearAllMocks();
  });
  describe('Valid token', () => {
    test('should authenticate user with valid token', async () => {
      // Arrange
      const mockUser = {
        _id: 'user123',
        email: 'test@example.com',
        name: 'Test User'
      };
      
      jwt.verify.mockReturnValue({ userId: 'user123' });
      User.findById.mockResolvedValue(mockUser);
      // Act
      const response = await request(app)
        .get('/api/profile')
        .set('Authorization', 'Bearer valid.jwt.token');
      // Assert
      expect(response.status).toBe(200);
      expect(jwt.verify).toHaveBeenCalledWith(
        'valid.jwt.token',
        process.env.JWT_SECRET
      );
    });
  });
  describe('Missing token', () => {
    test('should return 401 when no Authorization header', async () => {
      const response = await request(app).get('/api/profile');
      expect(response.status).toBe(401);
      expect(response.body.error).toBe(
        'Missing or invalid authorization header'
      );
    });
    test('should return 401 when Authorization header lacks Bearer prefix', async () => {
      const response = await request(app)
        .get('/api/profile')
        .set('Authorization', 'Token invalid.jwt.token');
      expect(response.status).toBe(401);
      expect(response.body.error).toBe(
        'Missing or invalid authorization header'
      );
    });
  });
  describe('Invalid token', () => {
    test('should return 401 when token is malformed', async () => {
      jwt.verify.mockImplementation(() => {
        const error = new Error('jwt malformed');
        error.name = 'JsonWebTokenError';
        throw error;
      });
      const response = await request(app)
        .get('/api/profile')
        .set('Authorization', 'Bearer malformed.token');
      expect(response.status).toBe(401);
      expect(response.body.error).toBe('Invalid token');
    });
    test('should return 401 when token is expired', async () => {
      jwt.verify.mockImplementation(() => {
        const error = new Error('jwt expired');
        error.name = 'TokenExpiredError';
        throw error;
      });
      const response = await request(app)
        .get('/api/profile')
        .set('Authorization', 'Bearer expired.token');
      expect(response.status).toBe(401);
      expect(response.body.error).toBe('Token expired');
    });
  });
  describe('User not found', () => {
    test('should return 401 when user does not exist', async () => {
      jwt.verify.mockReturnValue({ userId: 'nonexistent' });
      User.findById.mockResolvedValue(null);
      const response = await request(app)
        .get('/api/profile')
        .set('Authorization', 'Bearer valid.jwt.token');
      expect(response.status).toBe(401);
      expect(response.body.error).toBe('User not found');
    });
  });
  describe('Unexpected errors', () => {
    test('should return 500 on database error', async () => {
      jwt.verify.mockReturnValue({ userId: 'user123' });
      User.findById.mockRejectedValue(new Error('DB connection failed'));
      const response = await request(app)
        .get('/api/profile')
        .set('Authorization', 'Bearer valid.jwt.token');
      expect(response.status).toBe(500);
      expect(response.body.error).toBe('Authentication failed');
    });
  });
});

 
## Handoff Notes
Tests ready for integration with CI/CD. Code ready for Reviewer agent evaluation.