Unit testing methods for middleware

Unit Testing Methods for Middleware

Unit testing Koa2 middleware is a crucial step in ensuring the correctness of middleware functionality. Testing middleware requires simulating request and response objects to verify whether the middleware behaves as expected. Below are detailed introductions to several common testing methods.

Choosing Testing Tools

Commonly used testing tools include Mocha, Jest, and AVA. These tools provide assertion libraries and test runtime environments. Taking Mocha as an example, it can be configured with the Chai assertion library as follows:

const chai = require('chai');
const expect = chai.expect;
const sinon = require('sinon');

Basic Testing Methods

The basic idea for testing middleware is to create a mock context object. Koa provides the koa-test-utils package, or you can create one manually:

const Koa = require('koa');
const app = new Koa();

function createContext(req = {}) {
  const ctx = app.createContext(req);
  return ctx;
}

Testing a simple logging middleware:

async function logger(ctx, next) {
  console.log(`Received ${ctx.method} ${ctx.url}`);
  await next();
}

describe('Logger Middleware', () => {
  it('should log request method and url', async () => {
    const ctx = createContext({
      method: 'GET',
      url: '/test'
    });
    const consoleSpy = sinon.spy(console, 'log');
    
    await logger(ctx, () => {});
    
    expect(consoleSpy.calledWith('Received GET /test')).to.be.true;
    consoleSpy.restore();
  });
});

Testing Asynchronous Middleware

For middleware containing asynchronous operations, special attention should be paid to the testing flow:

async function fetchData(ctx, next) {
  ctx.data = await someAsyncOperation();
  await next();
}

describe('Async Middleware', () => {
  it('should attach data to context', async () => {
    const ctx = createContext();
    const mockData = { id: 1, name: 'Test' };
    sinon.stub(someAsyncOperation).resolves(mockData);
    
    await fetchData(ctx, () => {});
    
    expect(ctx.data).to.deep.equal(mockData);
  });
});

Testing Error-Handling Middleware

Error-handling middleware requires testing both normal and exceptional cases:

async function errorHandler(ctx, next) {
  try {
    await next();
  } catch (err) {
    ctx.status = err.status || 500;
    ctx.body = { error: err.message };
  }
}

describe('Error Handler', () => {
  it('should catch and process errors', async () => {
    const ctx = createContext();
    const error = new Error('Test error');
    error.status = 400;
    
    await errorHandler(ctx, () => { throw error; });
    
    expect(ctx.status).to.equal(400);
    expect(ctx.body.error).to.equal('Test error');
  });
});

Testing Middleware Chains

When multiple middlewares are combined, their interactions need to be tested:

describe('Middleware Chain', () => {
  it('should execute in correct order', async () => {
    const ctx = createContext();
    const calls = [];
    
    const mw1 = async (ctx, next) => {
      calls.push(1);
      await next();
      calls.push(4);
    };
    
    const mw2 = async (ctx, next) => {
      calls.push(2);
      await next();
      calls.push(3);
    };
    
    const composed = compose([mw1, mw2]);
    await composed(ctx);
    
    expect(calls).to.deep.equal([1, 2, 3, 4]);
  });
});

Simulating Requests and Responses

When testing middleware that handles request parameters, you can simulate them like this:

async function queryParser(ctx, next) {
  ctx.parsedQuery = ctx.query;
  await next();
}

describe('Query Parser', () => {
  it('should parse query parameters', async () => {
    const ctx = createContext({
      url: '/test?name=Koa&version=2'
    });
    
    await queryParser(ctx, () => {});
    
    expect(ctx.parsedQuery).to.deep.equal({
      name: 'Koa',
      version: '2'
    });
  });
});

Testing Status Codes and Response Headers

Verify middleware modifications to response status and headers:

async function setCache(ctx, next) {
  ctx.set('Cache-Control', 'max-age=3600');
  await next();
}

describe('Cache Middleware', () => {
  it('should set cache header', async () => {
    const ctx = createContext();
    
    await setCache(ctx, () => {});
    
    expect(ctx.response.get('Cache-Control')).to.equal('max-age=3600');
  });
});

Testing File Upload Middleware

Testing file upload middleware requires simulating multipart requests:

const fs = require('fs');
const path = require('path');
const FormData = require('form-data');
const http = require('http');

async function uploadHandler(ctx) {
  const file = ctx.request.files.file;
  const reader = fs.createReadStream(file.path);
  const stream = fs.createWriteStream(path.join(__dirname, 'uploads', file.name));
  reader.pipe(stream);
  ctx.body = 'Upload success';
}

describe('File Upload', () => {
  it('should handle file upload', (done) => {
    const form = new FormData();
    form.append('file', fs.createReadStream('test.txt'));
    
    const req = http.request({
      method: 'POST',
      headers: form.getHeaders()
    }, (res) => {
      let data = '';
      res.on('data', (chunk) => data += chunk);
      res.on('end', () => {
        expect(data).to.equal('Upload success');
        done();
      });
    });
    
    form.pipe(req);
  });
});

Testing Authentication Middleware

Authentication middleware typically needs to verify tokens or sessions:

async function auth(ctx, next) {
  const token = ctx.headers.authorization;
  if (!token) {
    ctx.throw(401, 'Unauthorized');
  }
  ctx.user = verifyToken(token);
  await next();
}

describe('Auth Middleware', () => {
  it('should reject requests without token', async () => {
    const ctx = createContext();
    let error;
    
    try {
      await auth(ctx, () => {});
    } catch (err) {
      error = err;
    }
    
    expect(error.status).to.equal(401);
  });
  
  it('should attach user for valid token', async () => {
    const ctx = createContext({
      headers: { authorization: 'valid.token.here' }
    });
    sinon.stub(verifyToken).returns({ id: 1 });
    
    await auth(ctx, () => {});
    
    expect(ctx.user).to.deep.equal({ id: 1 });
  });
});

Testing Database Operation Middleware

When middleware involves database operations, use mocks or in-memory databases:

async function getUser(ctx, next) {
  ctx.user = await User.findById(ctx.params.id);
  await next();
}

describe('User Middleware', () => {
  it('should fetch user from database', async () => {
    const mockUser = { id: 1, name: 'Test' };
    const User = {
      findById: sinon.stub().resolves(mockUser)
    };
    const ctx = createContext();
    ctx.params = { id: 1 };
    
    await getUser(ctx, () => {});
    
    expect(ctx.user).to.equal(mockUser);
    expect(User.findById.calledWith(1)).to.be.true;
  });
});

Testing Performance Monitoring Middleware

Example of testing middleware that measures execution time:

async function timing(ctx, next) {
  const start = Date.now();
  await next();
  const duration = Date.now() - start;
  ctx.set('X-Response-Time', `${duration}ms`);
}

describe('Timing Middleware', () => {
  it('should measure response time', async () => {
    const ctx = createContext();
    const delay = 100;
    
    await timing(ctx, async () => {
      await new Promise(resolve => setTimeout(resolve, delay));
    });
    
    const time = parseInt(ctx.response.get('X-Response-Time'));
    expect(time).to.be.at.least(delay);
  });
});

Testing Route-Level Middleware

Testing middleware specific to certain routes:

const router = require('koa-router')();

router.get('/users/:id', 
  auth,
  getUser,
  async (ctx) => {
    ctx.body = ctx.user;
  }
);

describe('Route with Middleware', () => {
  it('should chain middleware correctly', async () => {
    const ctx = createContext({
      method: 'GET',
      url: '/users/1',
      headers: { authorization: 'valid.token' }
    });
    sinon.stub(verifyToken).returns({ id: 1 });
    sinon.stub(User, 'findById').resolves({ id: 1, name: 'Test' });
    
    await router.routes()(ctx, () => {});
    
    expect(ctx.body).to.deep.equal({ id: 1, name: 'Test' });
  });
});

Testing Side Effects of Middleware

Some middleware modifies global state, which requires isolation during testing:

let requestCount = 0;

async function countRequests(ctx, next) {
  requestCount++;
  await next();
}

describe('Request Counter', () => {
  beforeEach(() => {
    requestCount = 0;
  });
  
  it('should increment counter', async () => {
    const ctx = createContext();
    
    await countRequests(ctx, () => {});
    
    expect(requestCount).to.equal(1);
  });
});

Testing Configurable Middleware

Testing middleware that accepts configuration parameters:

function createCacheMiddleware(options = {}) {
  return async function cache(ctx, next) {
    ctx.set('Cache-Control', `max-age=${options.maxAge || 0}`);
    await next();
  };
}

describe('Configurable Middleware', () => {
  it('should use provided maxAge', async () => {
    const ctx = createContext();
    const cache = createCacheMiddleware({ maxAge: 3600 });
    
    await cache(ctx, () => {});
    
    expect(ctx.response.get('Cache-Control')).to.equal('max-age=3600');
  });
});