基于Serverless的AWS Lambda代码需用依赖注入实现可测试性吗？

我正在使用Serverless Framework编写AWS Lambda代码，选用Jest作为测试框架，但正苦恼于如何让代码具备可测试性。我的项目初始结构如下：

Handler代码 #

import { fooService } from '../services';

export const createFooHandler: APIGatewayProxyHandlerV2 = async (event) => {
  // some validation process
  const { code, message } = await fooService.create(event.body);
  return { statusCode: code, body: JSON.stringify({message}) }
}

Service代码 #

import * as storage from '../storage';

export const fooService = {
  create: async (json: any) => {
    const foo = Foo.parse(json)
    const result = await storage.createFoo(foo);
    // .. some process
    return { code, message };
  }
}

Storage代码 #

const db = !process.env.IS_OFFLINE
  ? new DynamoDB.DocumentClient()
  : new DynamoDB.DocumentClient({
    region: "localhost",
    endpoint: "http://localhost:8000"
  });

export async function createFoo(foo: Foo) {...}

在此结构下，我是否必须使用依赖注入（DI）才能编写可测试的代码？

回答 #

不一定非要用依赖注入（DI），你可以用Jest自带的**模块模拟（mock）**能力实现测试，不用大规模重构代码；当然DI也是让代码更易测试的可靠方案，适合复杂项目场景。

方案1：用Jest Mock快速实现测试（无需改现有代码结构） #

Jest可以直接mock模块或函数，隔离真实依赖（比如DynamoDB操作），专注测试业务逻辑。

测试Handler

// createFooHandler.test.ts
import { createFooHandler } from './createFooHandler';
import { fooService } from '../services';

// Mock整个fooService模块
jest.mock('../services', () => ({
  fooService: {
    create: jest.fn().mockResolvedValue({ code: 200, message: 'Foo创建成功' })
  }
}));

describe('createFooHandler', () => {
  it('应返回200状态码和成功消息', async () => {
    const event = { body: JSON.stringify({ name: '测试Foo' }) } as any;
    const result = await createFooHandler(event);
    
    expect(result.statusCode).toBe(200);
    expect(JSON.parse(result.body).message).toBe('Foo创建成功');
    expect(fooService.create).toHaveBeenCalledWith(event.body);
  });
});

测试Service

// fooService.test.ts
import { fooService } from './fooService';
import * as storage from '../storage';

// Mock storage模块的createFoo函数
jest.mock('../storage', () => ({
  createFoo: jest.fn().mockResolvedValue({ id: 'foo_123' })
}));

describe('fooService.create', () => {
  it('应解析输入并调用storage.createFoo', async () => {
    const input = { name: '测试Foo' };
    const result = await fooService.create(input);
    
    expect(storage.createFoo).toHaveBeenCalledWith(Foo.parse(input));
    expect(result.code).toBe(200); // 匹配你的业务逻辑返回码
  });
});

方案2：引入轻量DI（适合复杂项目） #

如果项目依赖关系越来越复杂，DI能让依赖更显式，测试更灵活。你可以给函数添加可选的依赖参数，不用完全重构为DI容器模式：

修改Handler代码

import { fooService } from '../services';

// 新增可选的dependencies参数，默认使用真实的fooService
export const createFooHandler: APIGatewayProxyHandlerV2 = async (event, _context, dependencies = { fooService }) => {
  const { code, message } = await dependencies.fooService.create(event.body);
  return { statusCode: code, body: JSON.stringify({ message }) };
}

测试Handler

// createFooHandler.test.ts
import { createFooHandler } from './createFooHandler';

describe('createFooHandler', () => {
  it('应返回成功响应', async () => {
    // 手动创建mock依赖
    const mockFooService = {
      create: jest.fn().mockResolvedValue({ code: 200, message: '创建成功' })
    };
    const event = { body: JSON.stringify({}) } as any;
    
    const result = await createFooHandler(event, null, { fooService: mockFooService });
    
    expect(mockFooService.create).toHaveBeenCalled();
    expect(result.statusCode).toBe(200);
  });
});

总结 #

• 小项目/简单依赖：用Jest Mock足够，不用强制引入DI，快速实现测试覆盖。
• 大项目/复杂依赖：DI能让代码的依赖关系更清晰，降低后期维护成本，测试也更灵活。

内容的提问来源于stack exchange，提问作者hardyeats