中间件的单元测试方法

中间件的单元测试方法

Koa2中间件的单元测试是确保中间件功能正确性的关键步骤。测试中间件需要模拟请求和响应对象，验证中间件的行为是否符合预期。下面详细介绍几种常见的测试方法。

测试工具选择

常用的测试工具包括Mocha、Jest和AVA。这些工具提供了断言库和测试运行环境。以Mocha为例，配合Chai断言库可以这样配置：

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

基本测试方法

测试中间件的基本思路是创建模拟的上下文对象。Koa提供了koa-test-utils工具包，也可以手动创建：

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

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

测试一个简单的日志中间件：

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();
  });
});

测试异步中间件

对于包含异步操作的中间件，需要特别注意测试流程：

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);
  });
});

测试错误处理中间件

错误处理中间件需要测试正常和异常两种情况：

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');
  });
});

测试中间件链

多个中间件组合使用时，需要测试它们的交互：

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]);
  });
});

模拟请求和响应

测试需要处理请求参数的中间件时，可以这样模拟：

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'
    });
  });
});

测试状态码和响应头

验证中间件对响应状态和头的修改：

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');
  });
});

测试文件上传中间件

文件上传中间件的测试需要模拟multipart请求：

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);
  });
});

测试认证中间件

认证中间件通常需要验证token或session：

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 });
  });
});

测试数据库操作中间件

中间件包含数据库操作时，应该使用mock或内存数据库：

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;
  });
});

测试性能监控中间件

测量中间件执行时间的测试示例：

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);
  });
});

测试路由级中间件

针对特定路由的中间件测试：

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' });
  });
});

测试中间件的副作用

有些中间件会修改全局状态，测试时需要隔离：

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);
  });
});

测试配置型中间件

接受配置参数的中间件测试：

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');
  });
});