Chapter 10: Comprehensive Testing: Unit, Integration, and E2E

// jest.config.js
module.exports = {
  // Automatically clear mock calls and instances between every test
  clearMocks: true,

  // Indicates whether the coverage information should be collected while executing the test
  collectCoverage: true,

  // An array of glob patterns indicating a set of files for which coverage information should be collected
  collectCoverageFrom: ['src/**/*.js', '!src/app.js', '!src/config/*.js', '!src/routes/*.js', '!src/server.js'],

  // The directory where Jest should output its coverage files
  coverageDirectory: 'coverage',

  // An array of regexp pattern strings that are matched against all test paths, matched tests are skipped
  testPathIgnorePatterns: ['/node_modules/', '/dist/'],

  // The test environment that will be used for testing
  testEnvironment: 'node',

  // Run tests from one or more projects
  projects: [
    {
      displayName: 'unit',
      testMatch: ['<rootDir>/tests/unit/**/*.test.js'],
      setupFiles: ['dotenv/config'], // Load .env for unit tests
    },
    {
      displayName: 'integration',
      testMatch: ['<rootDir>/tests/integration/**/*.test.js'],
      setupFiles: ['dotenv/config'], // Load .env for integration tests
      // Setup files for integration tests (e.g., database setup/teardown)
      setupFilesAfterEnv: ['<rootDir>/tests/integration/setup.js'],
    },
    {
      displayName: 'e2e',
      testMatch: ['<rootDir>/tests/e2e/**/*.test.js'],
      setupFiles: ['dotenv/config'], // Load .env for e2e tests
      // Setup files for e2e tests (e.g., starting/stopping the server)
      setupFilesAfterEnv: ['<rootDir>/tests/e2e/setup.js'],
    },
  ],
};

// package.json
{
  "name": "your-project",
  "version": "1.0.0",
  "description": "Node.js backend project",
  "main": "src/server.js",
  "scripts": {
    "start": "node src/server.js",
    "dev": "nodemon src/server.js",
    "test": "jest",
    "test:unit": "jest --projects unit",
    "test:integration": "jest --projects integration",
    "test:e2e": "jest --projects e2e",
    "test:watch": "jest --watch",
    "test:coverage": "jest --coverage"
  },
  "dependencies": {
    // ... your existing dependencies
  },
  "devDependencies": {
    "jest": "^29.x.x",
    "supertest": "^6.x.x",
    "@jest/globals": "^29.x.x",
    "dotenv": "^16.x.x",
    "nodemon": "^3.x.x"
  }
}

// src/config/index.js (example, adjust to your actual config loading)
require('dotenv').config({ path: process.env.NODE_ENV === 'test' ? '.env.test' : '.env' });

const config = {
  env: process.env.NODE_ENV || 'development',
  port: process.env.PORT || 3000,
  database: {
    url: process.env.DATABASE_URL || 'postgresql://user:password@localhost:5432/main_db',
  },
  jwt: {
    secret: process.env.JWT_SECRET || 'your_default_secret',
    expiresIn: process.env.JWT_EXPIRES_IN || '1h',
  },
  logLevel: process.env.LOG_LEVEL || 'info',
  // ... other configurations
};

module.exports = config;

// src/utils/auth.js
const jwt = require('jsonwebtoken');
const config = require('../config');
const logger = require('../utils/logger'); // Assuming you have a logger utility

/**
 * Generates a JWT token for a given user.
 * @param {object} user - The user object containing id, email, roles.
 * @returns {string} The generated JWT token.
 */
function generateAuthToken(user) {
  try {
    const payload = {
      id: user.id,
      email: user.email,
      roles: user.roles,
    };
    const token = jwt.sign(payload, config.jwt.secret, {
      expiresIn: config.jwt.expiresIn,
    });
    logger.debug(`Generated JWT token for user: ${user.email}`);
    return token;
  } catch (error) {
    logger.error(`Error generating auth token for user ${user.email}: ${error.message}`);
    throw new Error('Failed to generate authentication token');
  }
}

/**
 * Verifies a JWT token.
 * @param {string} token - The JWT token to verify.
 * @returns {object} The decoded payload if valid.
 * @throws {Error} If the token is invalid or expired.
 */
function verifyAuthToken(token) {
  try {
    const decoded = jwt.verify(token, config.jwt.secret);
    logger.debug('Verified JWT token successfully.');
    return decoded;
  } catch (error) {
    logger.warn(`JWT token verification failed: ${error.message}`);
    if (error.name === 'TokenExpiredError') {
      throw new Error('Authentication token expired');
    }
    if (error.name === 'JsonWebTokenError') {
      throw new Error('Invalid authentication token');
    }
    throw new Error('Failed to verify authentication token');
  }
}

module.exports = {
  generateAuthToken,
  verifyAuthToken,
};

// tests/unit/utils/auth.test.js
const { generateAuthToken, verifyAuthToken } = require('../../../src/utils/auth');
const jwt = require('jsonwebtoken');
const config = require('../../../src/config');
const logger = require('../../../src/utils/logger'); // Import logger to mock it

// Mock the logger to prevent console output during tests
jest.mock('../../../src/utils/logger', () => ({
  debug: jest.fn(),
  info: jest.fn(),
  warn: jest.fn(),
  error: jest.fn(),
}));

describe('Auth Utilities - Unit Tests', () => {
  const mockUser = { id: 'user123', email: 'test@example.com', roles: ['user'] };
  const mockSecret = 'test_jwt_secret_for_unit_tests';
  const mockExpiresIn = '1h';

  // Set mock config values for JWT
  beforeAll(() => {
    config.jwt.secret = mockSecret;
    config.jwt.expiresIn = mockExpiresIn;
  });

  afterEach(() => {
    jest.clearAllMocks(); // Clear mock calls after each test
  });

  describe('generateAuthToken', () => {
    it('should generate a valid JWT token', () => {
      const token = generateAuthToken(mockUser);
      expect(token).toBeDefined();
      expect(typeof token).toBe('string');

      // Verify the token content
      const decoded = jwt.verify(token, mockSecret);
      expect(decoded.id).toBe(mockUser.id);
      expect(decoded.email).toBe(mockUser.email);
      expect(decoded.roles).toEqual(mockUser.roles);
      expect(decoded.exp).toBeDefined();
      expect(logger.debug).toHaveBeenCalledWith(expect.stringContaining(`Generated JWT token for user: ${mockUser.email}`));
    });

    it('should throw an error if JWT signing fails', () => {
      // Temporarily mock jwt.sign to throw an error
      jest.spyOn(jwt, 'sign').mockImplementationOnce(() => {
        throw new Error('JWT signing failed');
      });

      expect(() => generateAuthToken(mockUser)).toThrow('Failed to generate authentication token');
      expect(logger.error).toHaveBeenCalledWith(expect.stringContaining(`Error generating auth token for user ${mockUser.email}: JWT signing failed`));
    });
  });

  describe('verifyAuthToken', () => {
    it('should successfully verify a valid token', () => {
      const token = jwt.sign(mockUser, mockSecret, { expiresIn: mockExpiresIn });
      const decoded = verifyAuthToken(token);
      expect(decoded.id).toBe(mockUser.id);
      expect(decoded.email).toBe(mockUser.email);
      expect(decoded.roles).toEqual(mockUser.roles);
      expect(logger.debug).toHaveBeenCalledWith('Verified JWT token successfully.');
    });

    it('should throw an error for an expired token', () => {
      // Generate an expired token
      const expiredToken = jwt.sign(mockUser, mockSecret, { expiresIn: '0s' });
      // Wait for a short moment to ensure token expires
      jest.advanceTimersByTime(100); // Advance timers by 100ms
      expect(() => verifyAuthToken(expiredToken)).toThrow('Authentication token expired');
      expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('JWT token verification failed: jwt expired'));
    });

    it('should throw an error for an invalid token (malformed)', () => {
      const invalidToken = 'invalid.jwt.token';
      expect(() => verifyAuthToken(invalidToken)).toThrow('Invalid authentication token');
      expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('JWT token verification failed: jwt malformed'));
    });

    it('should throw an error for an invalid token (wrong secret)', () => {
      const tokenWithWrongSecret = jwt.sign(mockUser, 'wrong_secret', { expiresIn: mockExpiresIn });
      expect(() => verifyAuthToken(tokenWithWrongSecret)).toThrow('Invalid authentication token');
      expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('JWT token verification failed: invalid signature'));
    });
  });
});

npm run test:unit

// tests/integration/setup.js
const { connectDB, disconnectDB } = require('../../src/config/database'); // Assuming you have database connection utility
const { seedDatabase, clearDatabase } = require('./database-helper'); // We'll create this next
const app = require('../../src/app'); // Your main Express/Fastify app instance
const supertest = require('supertest');

let server; // To hold the server instance
global.request = supertest(app); // Make supertest instance globally available for convenience

beforeAll(async () => {
  // Ensure NODE_ENV is set to 'test'
  process.env.NODE_ENV = 'test';
  require('dotenv').config({ path: '.env.test' }); // Load test environment variables

  // 1. Connect to the test database
  await connectDB();
  console.log('Connected to test database.');

  // 2. Clear and seed the database with initial data
  await clearDatabase();
  await seedDatabase();
  console.log('Test database cleared and seeded.');

  // 3. Start the server
  server = app.listen(process.env.PORT || 3001, () => {
    console.log(`Test server running on port ${process.env.PORT || 3001}`);
  });
});

afterAll(async () => {
  // 1. Disconnect from the database
  await disconnectDB();
  console.log('Disconnected from test database.');

  // 2. Close the server
  await server.close();
  console.log('Test server closed.');
});

afterEach(async () => {
  // Optionally clear database or rollback transactions after each test
  // This helps ensure test isolation
  await clearDatabase(); // Or use transactions for faster rollback
  await seedDatabase();
});

// tests/integration/database-helper.js
const { AppDataSource } = require('../../src/config/database'); // Assuming TypeORM or similar
const logger = require('../../src/utils/logger');
const bcrypt = require('bcryptjs');

// Example models (adjust to your actual models)
const User = require('../../src/models/User'); // Assuming you have a User model
const Product = require('../../src/models/Product'); // Assuming you have a Product model

async function clearDatabase() {
  if (AppDataSource.isInitialized) {
    try {
      const entities = AppDataSource.entityMetadatas;
      for (const entity of entities) {
        const repository = AppDataSource.getRepository(entity.name);
        await repository.query(`TRUNCATE TABLE "${entity.tableName}" RESTART IDENTITY CASCADE;`);
      }
      logger.info('Test database cleared successfully.');
    } catch (error) {
      logger.error(`Error clearing test database: ${error.message}`);
      throw error;
    }
  }
}

async function seedDatabase() {
  if (AppDataSource.isInitialized) {
    try {
      const userRepository = AppDataSource.getRepository(User);
      const productRepository = AppDataSource.getRepository(Product);

      // Create a test admin user
      const hashedPassword = await bcrypt.hash('password123', 10);
      const adminUser = userRepository.create({
        username: 'admin_test',
        email: 'admin@test.com',
        password: hashedPassword,
        roles: ['admin', 'user'],
        isActive: true,
      });
      await userRepository.save(adminUser);

      // Create a test regular user
      const regularUserPassword = await bcrypt.hash('userpassword', 10);
      const regularUser = userRepository.create({
        username: 'user_test',
        email: 'user@test.com',
        password: regularUserPassword,
        roles: ['user'],
        isActive: true,
      });
      await userRepository.save(regularUser);

      // Create some test products
      await productRepository.save([
        productRepository.create({ name: 'Test Product 1', description: 'Description 1', price: 10.99, stock: 100 }),
        productRepository.create({ name: 'Test Product 2', description: 'Description 2', price: 20.50, stock: 50 }),
      ]);

      logger.info('Test database seeded successfully.');
    } catch (error) {
      logger.error(`Error seeding test database: ${error.message}`);
      throw error;
    }
  }
}

module.exports = {
  clearDatabase,
  seedDatabase,
};

// src/server.js
const app = require('./app'); // Your Express app instance
const config = require('./config');
const logger = require('./utils/logger');
const { connectDB } = require('./config/database');

// Connect to database
connectDB()
  .then(() => {
    logger.info('Database connected successfully.');
    // Only start the server if not in test environment
    if (config.env !== 'test') {
      app.listen(config.port, () => {
        logger.info(`Server running on port ${config.port} in ${config.env} mode.`);
      });
    }
  })
  .catch((err) => {
    logger.error('Failed to connect to database:', err);
    process.exit(1);
  });

module.exports = app; // Export the app for testing

// tests/integration/routes/auth.test.js
const { AppDataSource } = require('../../../src/config/database');
const User = require('../../../src/models/User'); // Assuming you have a User model
const config = require('../../../src/config');
const jwt = require('jsonwebtoken');

describe('Auth Routes - Integration Tests', () => {
  let userRepository;

  beforeAll(() => {
    userRepository = AppDataSource.getRepository(User);
  });

  it('should register a new user successfully', async () => {
    const newUser = {
      username: 'newuser',
      email: 'newuser@example.com',
      password: 'securePassword123',
    };

    const response = await global.request
      .post('/api/auth/register') // Assuming your registration endpoint
      .send(newUser)
      .expect(201); // Expect 201 Created

    expect(response.body).toHaveProperty('message', 'User registered successfully');
    expect(response.body).toHaveProperty('user');
    expect(response.body.user).toHaveProperty('id');
    expect(response.body.user).toHaveProperty('username', newUser.username);
    expect(response.body.user).toHaveProperty('email', newUser.email);
    expect(response.body.user).not.toHaveProperty('password'); // Password should not be returned

    // Verify user exists in the database
    const userInDb = await userRepository.findOneBy({ email: newUser.email });
    expect(userInDb).toBeDefined();
    expect(userInDb.username).toBe(newUser.username);
    expect(userInDb.email).toBe(newUser.email);
    expect(userInDb.roles).toEqual(['user']); // Default role
  });

  it('should prevent registration with an existing email', async () => {
    const existingUser = {
      username: 'existinguser',
      email: 'admin@test.com', // Email from our seed data
      password: 'anotherPassword',
    };

    const response = await global.request
      .post('/api/auth/register')
      .send(existingUser)
      .expect(409); // Expect 409 Conflict

    expect(response.body).toHaveProperty('message', 'Email already registered');
  });

  it('should login an existing user and return a JWT token', async () => {
    const loginCredentials = {
      email: 'admin@test.com',
      password: 'password123',
    };

    const response = await global.request
      .post('/api/auth/login') // Assuming your login endpoint
      .send(loginCredentials)
      .expect(200); // Expect 200 OK

    expect(response.body).toHaveProperty('message', 'Logged in successfully');
    expect(response.body).toHaveProperty('token');
    expect(typeof response.body.token).toBe('string');

    // Verify the JWT token
    const decodedToken = jwt.verify(response.body.token, config.jwt.secret);
    expect(decodedToken).toHaveProperty('id');
    expect(decodedToken).toHaveProperty('email', loginCredentials.email);
    expect(decodedToken).toHaveProperty('roles', expect.arrayContaining(['admin', 'user']));
  });

  it('should return 401 for invalid login credentials', async () => {
    const invalidCredentials = {
      email: 'user@test.com',
      password: 'wrongpassword',
    };

    const response = await global.request
      .post('/api/auth/login')
      .send(invalidCredentials)
      .expect(401); // Expect 401 Unauthorized

    expect(response.body).toHaveProperty('message', 'Invalid credentials');
  });
});

npm run test:integration

// tests/e2e/setup.js
const { connectDB, disconnectDB } = require('../../src/config/database');
const { seedDatabase, clearDatabase } = require('../integration/database-helper'); // Re-use helper
const app = require('../../src/app');
const supertest = require('supertest');

let server;
global.request = supertest(app);

beforeAll(async () => {
  process.env.NODE_ENV = 'test';
  require('dotenv').config({ path: '.env.test' });

  await connectDB();
  console.log('Connected to test database for E2E.');

  await clearDatabase();
  await seedDatabase();
  console.log('Test database for E2E cleared and seeded.');

  server = app.listen(process.env.PORT || 3001, () => {
    console.log(`E2E test server running on port ${process.env.PORT || 3001}`);
  });
});

afterAll(async () => {
  await disconnectDB();
  console.log('Disconnected from test database for E2E.');

  await server.close();
  console.log('E2E test server closed.');
});

afterEach(async () => {
  await clearDatabase();
  await seedDatabase();
});

// tests/e2e/user-product-flow.test.js
describe('User Product Management Workflow - E2E Tests', () => {
  let userToken = '';
  let userId = '';
  let productId = '';

  const testUser = {
    username: 'e2euser',
    email: 'e2e@example.com',
    password: 'e2ePassword123',
  };

  const testProduct = {
    name: 'E2E Test Product',
    description: 'This is a product created during an E2E test.',
    price: 99.99,
    stock: 50,
  };

  it('should register a new user', async () => {
    const res = await global.request
      .post('/api/auth/register')
      .send(testUser)
      .expect(201);

    expect(res.body).toHaveProperty('message', 'User registered successfully');
    expect(res.body.user).toHaveProperty('id');
    userId = res.body.user.id;
  });

  it('should log in the newly registered user', async () => {
    const res = await global.request
      .post('/api/auth/login')
      .send({ email: testUser.email, password: testUser.password })
      .expect(200);

    expect(res.body).toHaveProperty('message', 'Logged in successfully');
    expect(res.body).toHaveProperty('token');
    userToken = res.body.token; // Store the token for subsequent requests
  });

  it('should allow the logged-in user to create a product', async () => {
    const res = await global.request
      .post('/api/products') // Assuming your product creation endpoint
      .set('Authorization', `Bearer ${userToken}`) // Use the stored token
      .send(testProduct)
      .expect(201);

    expect(res.body).toHaveProperty('message', 'Product created successfully');
    expect(res.body.product).toHaveProperty('id');
    expect(res.body.product).toHaveProperty('name', testProduct.name);
    expect(res.body.product).toHaveProperty('price', testProduct.price);
    productId = res.body.product.id; // Store the product ID
  });

  it('should allow the logged-in user to fetch the created product', async () => {
    const res = await global.request
      .get(`/api/products/${productId}`)
      .set('Authorization', `Bearer ${userToken}`)
      .expect(200);

    expect(res.body).toHaveProperty('product');
    expect(res.body.product).toHaveProperty('id', productId);
    expect(res.body.product).toHaveProperty('name', testProduct.name);
  });

  it('should allow the logged-in user to update the created product', async () => {
    const updatedProductData = {
      name: 'E2E Updated Product',
      price: 105.00,
    };

    const res = await global.request
      .put(`/api/products/${productId}`)
      .set('Authorization', `Bearer ${userToken}`)
      .send(updatedProductData)
      .expect(200);

    expect(res.body).toHaveProperty('message', 'Product updated successfully');
    expect(res.body.product).toHaveProperty('id', productId);
    expect(res.body.product).toHaveProperty('name', updatedProductData.name);
    expect(res.body.product).toHaveProperty('price', updatedProductData.price);
  });

  it('should prevent an unauthenticated user from accessing products', async () => {
    await global.request
      .get('/api/products')
      .expect(401); // Expect 401 Unauthorized
  });

  it('should allow the logged-in user to delete the created product', async () => {
    await global.request
      .delete(`/api/products/${productId}`)
      .set('Authorization', `Bearer ${userToken}`)
      .expect(200); // Expect 200 OK

    // Verify product is no longer fetchable
    await global.request
      .get(`/api/products/${productId}`)
      .set('Authorization', `Bearer ${userToken}`)
      .expect(404); // Expect 404 Not Found
  });
});

npm run test:e2e

npm test