如何使用jest模拟S3？

Question

我正在尝试编写一个上传测试。 但我不明白如何正确使用 jest.mock('aws-sdk')。

export class S3Service {
  private readonly s3: S3;
  private readonly bucket: string;
  constructor(private readonly configService: ConfigService) {
    this.s3 = new S3({
      accessKeyId: this.configService.get(''),
      secretAccessKey: this.configService.get(''),
      region: this.configService.get(''),
    });
    this.bucket = this.configService.get('');
  }
async upload(name: string, contentType: string, buffer: Buffer): Promise<string> {
    const upload = await this.s3.upload({params...}).promise();
    return upload;
  }
}

- luickx

Answer 1

这是单元测试的解决方案：

s3Service.ts文件：

import { S3 } from 'aws-sdk';

export class S3Service {
  private readonly s3: S3;
  private readonly bucket: string;
  constructor(private readonly configService) {
    this.s3 = new S3({
      accessKeyId: this.configService.get(''),
      secretAccessKey: this.configService.get(''),
      region: this.configService.get(''),
    });
    this.bucket = this.configService.get('');
  }
  public async upload(name: string, contentType: string, buffer: Buffer): Promise<any> {
    const bucket = this.bucket;
    const params = { Bucket: bucket, Key: 'key', Body: buffer };
    const upload = await this.s3.upload(params).promise();
    return upload;
  }
}

s3Service.test.ts：

import { S3Service } from './s3Service';

const mS3Instance = {
  upload: jest.fn().mockReturnThis(),
  promise: jest.fn(),
};

jest.mock('aws-sdk', () => {
  return { S3: jest.fn(() => mS3Instance) };
});

describe('61830632', () => {
  it('should upload correctly', async () => {
    const configService = {
      get: jest
        .fn()
        .mockReturnValueOnce('accessKeyId')
        .mockReturnValueOnce('secretAccessKey')
        .mockReturnValueOnce('us-east')
        .mockReturnValueOnce('bucket-dev'),
    };
    mS3Instance.promise.mockResolvedValueOnce('fake response');
    const s3Service = new S3Service(configService);
    const actual = await s3Service.upload('name', 'contentType', Buffer.from('ok'));
    expect(actual).toEqual('fake response');
    expect(mS3Instance.upload).toBeCalledWith({ Bucket: 'bucket-dev', Key: 'key', Body: Buffer.from('ok') });
  });
});

单元测试结果覆盖率为100%：

 PASS  stackoverflow/61830632/s3Service.test.ts (11.362s)
  61830632
    ✓ should upload correctly (6ms)

--------------|---------|----------|---------|---------|-------------------
File          | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s 
--------------|---------|----------|---------|---------|-------------------
All files     |     100 |      100 |     100 |     100 |                   
 s3Service.ts |     100 |      100 |     100 |     100 |                   
--------------|---------|----------|---------|---------|-------------------
Test Suites: 1 passed, 1 total
Tests:       1 passed, 1 total
Snapshots:   0 total
Time:        12.738s

- Lin Du

---

感谢您提供这样详细的答案。从概念上讲，jest.fn().mockReturnThis()是什么意思？它是否允许您链接调用？ - cischa

是的，它允许您链接调用。 - Lin Du

@slideshowp2 将您的代码复制到我的测试中，Jest 返回以下错误：ReferenceError: .../tests/user_handler.spec.ts: jest.mock() 的模块工厂不允许引用任何超出范围的变量。 无效的变量访问：mS3Instance 允许的对象：Array、ArrayBuffer、Atomics、BigInt、BigInt64Array、BigUint64Array、Boolean、Buffer、DTRACE_HTTP_CLIENT_REQUEST、DTRACE_HTTP_CLIENT_RESPONSE、DTRACE_HTTP_SERVER_REQUEST、DTRACE_HTTP_SERVER_RESPONSE、DTRACE_NET_SERVER_CONNECTION、DTRACE_NET_STREAM_END、DataView、Date、Error、EvalError、... - Benjamin Heinke

@BenjaminHeinke 这只是一个警告。将 mS3Instance 重命名为以 mock 开头的名称，例如 mockS3。 - timomeinen

我尝试了以下代码：const mockS3Instance = { putObject: jest.fn(), } console.log(mockS3Instance) jest.mock('aws-sdk', () => { return { S3: jest.fn(() => mockS3Instance) } });，但是在这一行代码 return { S3: jest.fn(() => mockS3Instance) } 上出现了错误 ReferenceError: Cannot access 'mockS3Instance' before initialization。 - Abhilash D K

Answer 2

这是我的解决方案：

jest.mock('aws-sdk', () => {
  class mockS3 {
    getSignedUrl(op, obj) {
      return 'url';
    }
  }
  return {
    ...jest.requireActual('aws-sdk'),
    S3: mockS3
  };
});

- akash ingole

Answer 3

如果您正在使用NestJS，则可能比您想象的要简单。

文件上传模块：

import { Module } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import { TypeOrmModule } from '@nestjs/typeorm';
import { S3 } from 'aws-sdk';
import { FileUploadController } from './file-upload.controller';
import { FileUploadRepository } from './file-upload.repository';
import { FileUploadService } from './file-upload.service';
@Module({
  imports: [TypeOrmModule.forFeature([FileUploadRepository])],
  controllers: [FileUploadController],
  providers: [
    FileUploadService,
    {
      provide: S3,
      useFactory: (configService: ConfigService) =>
        new S3({
          accessKeyId: configService.get('AWS_ACCESS_KEY'),
          secretAccessKey: configService.get('AWS_ACCESS_SECRET'),
          region: configService.get('AWS_REGION'),
        }),
    },
  ],
})
export class FileUploadModule {}

服务本身：

import { Injectable, InternalServerErrorException } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import { InjectRepository } from '@nestjs/typeorm';
import { S3 } from 'aws-sdk';
import { v4 as uuid } from 'uuid';
import { FileUpload } from './file-upload.entity';
import { FileUploadRepository } from './file-upload.repository';

@Injectable()
export class FileUploadService {
  constructor(
    @InjectRepository(FileUploadRepository)
    private readonly publicFileRepository: FileUploadRepository,
    private readonly configService: ConfigService,
    private readonly s3: S3,
  ) {}

  async uploadPublicFile(
    dataBuffer: Buffer,
    filename: string,
  ): Promise<FileUpload> {
    const uploadResult = await this.s3
      .upload({
        Bucket: this.configService.get('AWS_BUCKET_NAME'),
        Body: dataBuffer,
        Key: `${uuid()}-${filename}`,
      })
      .promise();

    const createdFile = this.publicFileRepository.create({
      key: uploadResult.Key,
      url: uploadResult.Location,
    });
    await this.publicFileRepository.save(createdFile);
    return createdFile;
  }

  async deletePublicFile(
    publicFileId: string,
    publicFileKey: string,
  ): Promise<FileUpload> {
    const response = await this.s3
      .deleteObject({
        Bucket: this.configService.get('AWS_BUCKET_NAME'),
        Key: publicFileKey,
      })
      .promise();
    if (!response) {
      throw new InternalServerErrorException(
        `Could not delete file ${publicFileKey}`,
      );
    }
    const { raw: deletedItem } = await this.publicFileRepository.delete(
      publicFileId,
    );
    return deletedItem;
  }
}

最后进行测试：

import { InternalServerErrorException } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import { Test, TestingModule } from '@nestjs/testing';
import { S3 } from 'aws-sdk';
import { mockFileUpload } from './file-upload.mock';
import { FileUploadRepository } from './file-upload.repository';
import { FileUploadService } from './file-upload.service';

export const mockFileUploadRepository = () => ({
  create: jest.fn(),
  save: jest.fn(),
  delete: jest.fn(),
});

const mS3Instance = {
  upload: jest.fn().mockReturnThis(),
  promise: jest.fn(),
  deleteObject: jest.fn().mockReturnThis(),
};

describe('FileUploadService', () => {
  let service: FileUploadService;
  let repository;
  let s3Service;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [
        FileUploadService,
        {
          provide: FileUploadRepository,
          useFactory: mockFileUploadRepository,
        },
        {
          provide: ConfigService,
          useValue: {
            get: jest.fn(),
          },
        },
        {
          provide: S3,
          useFactory: () => mS3Instance,
        },
      ],
    }).compile();

    service = module.get<FileUploadService>(FileUploadService);
    repository = module.get<FileUploadRepository>(FileUploadRepository);
    repository = module.get<FileUploadRepository>(FileUploadRepository);
    s3Service = module.get<S3>(S3);
  });

  describe('FileUploadService.uploadPublicFile', () => {
    it('should create public file and throw no error', async () => {
      repository.create.mockResolvedValue(mockFileUpload);
      repository.save.mockResolvedValue(mockFileUpload);

      s3Service.promise = jest.fn().mockResolvedValue({
        Key: 'some-key',
        Location: 'some-location',
      });

      const file = Buffer.alloc(513, '0');
      const response = await service.uploadPublicFile(file, 'somefilename');
      expect(response).toBeDefined();
    });
  });

  describe('FileUploadService.deletePublicFile', () => {
    it('should delete public file and throw no error', async () => {
      repository.delete.mockResolvedValue({ raw: mockFileUpload });
      repository.save.mockResolvedValue(mockFileUpload);

      s3Service.promise = jest.fn().mockResolvedValue({
        Key: 'some-key',
        Location: 'some-location',
      });

      const response = await service.deletePublicFile('someid', 'somefilename');
      expect(response).toBeDefined();
    });

    it('should not delete public file and throw InternalServerErrorException', async () => {
      repository.delete.mockResolvedValue({ raw: mockFileUpload });
      repository.save.mockResolvedValue(mockFileUpload);

      s3Service.promise = jest.fn().mockResolvedValue(null);

      const promise = service.deletePublicFile('someid', 'somefilename');
      expect(promise).rejects.toThrow(InternalServerErrorException);
    });
  });
});

- Lucas P

---

谢谢。我可以确认以上内容是有效的。 - Elte156

太感谢了，真是救命恩人。我在其他测试中使用过NestJS服务，但在处理S3时却变得有些愚笨，如果早点意识到有更简单的方法就好了。 - Kaluk

谢谢！我不得不做一个小改变，将 S3 放在双引号中 (provide: "S3")，因为我是这样在服务中注入它的：@Inject("S3") private readonly s3: S3, - Tobias

Answer 4

测试S3 aws-sdk的基本方法是这样的。假设我们在AWS Lambda中有用于删除S3的方法。

DeleteS3Object.js

const AWS = require('aws-sdk');


const DeleteS3Object = (testBucketParams) => {
  const s3 = new AWS.S3();

  try {
    const s3DeleteResponse = await s3.deleteObject(params).promise();
    debugger;
    console.log(`Delete S3 Object successfully:`, s3DeleteResponse);
    resolve(s3DeleteResponse);
  } catch (error) {
    console.log(`Delete S3 Object failed:`, JSON.stringify(error));
    reject(error);
  }

};

exports.handler = deleteS3Object;

DeleteS3Object.test.js

const AWSMock = require('aws-sdk-mock');
const AWS = require('aws-sdk');
const DeleteS3Object = require('./DeleteS3Object').handler;

describe('Test Delete S3 object', () => {
  beforeEach(() => {
    AWSMock.setSDKInstance(AWS);
  });

  afterEach(() => {
    AWSMock.restore('S3');
  });

  it('Should be successfully completed', async () => {
    const successResult = { success: true };
    AWSMock.mock('S3', 'deleteObject', (params, callback) => {
      expect(params).toEqual({ Bucket: 'test', Key: 'test' });
      return callback(null, successResult);
    });

    const paramsTest = { Bucket: 'test', Key: 'test' };

    const finalResponse = await DeleteS3Object(paramsTest);
    expect(finalResponse).toBe(successResult);
  });


  it('Should fail', async () => {
    const failResult = { success: false };
    AWSMock.mock('S3', 'deleteObject', (params, callback) => {
      expect(params).toEqual({ Bucket: 'test', Key: 'test' });
      return callback(failResult);
    });
    const paramsTest = {
      basicS3ParamList: { Bucket: 'test', Key: 'test' },
      timeToDelete: 1000
    };
    try {
      await DeleteS3Object(paramsTest);
    } catch (error) {
      expect(error).toEqual(failResult);
    }
  });
})

- Siddharth Sunchu

Answer 5

供参考，如果你正在导入具体的服务而不是完整的SDK，例如

import S3 from 'aws-sdk/clients/s3';

你需要将模拟工厂更改为

const mS3Instance = {
  upload: jest.fn().mockReturnThis(),
  promise: jest.fn(),
};

jest.mock('aws-sdk/clients/s3', () => {
  return jest.fn(() => mockS3Instance);
});

- Nick Hammond