Unit Testing AWS SDK in TypeScript

assert-to-have-received-put-command-command.ts

it('should persist user to dynamodb', async () => {
  await createUser(userInput);

  expect(mockDynamoDbDocumentClient).toHaveReceivedCommandWith(PutCommand, {
    TableName: 'TestUserTable',
    Item: userToCreate,
  });
});

assert-to-have-received-query-command.ts

it('should query user by role from dynamodb', async () => {
  expect(mockDynamoDbDocumentClient).toHaveReceivedCommandWith(QueryCommand, {
    TableName: config.userTableName,
    IndexName: config.userTableRoleIndexName,
    ExpressionAttributeNames: { '#role': 'role' },
    ExpressionAttributeValues: { ':role': role },
    KeyConditionExpression: '#role = :role',
  });
});

assert-wrapper-function-to-be-called-with.ts

it('should query user by role from dynamodb', async () => {
  expect(queryDynamoDb).toHaveBeenCalledWith<[QueryCommandInput]>({
    TableName: config.userTableName,
    IndexName: config.userTableRoleIndexName,
    ExpressionAttributeNames: { '#role': 'role' },
    ExpressionAttributeValues: { ':role': role },
    KeyConditionExpression: '#role = :role',
  });
});

compare-aws-sdk-v2-to-v3-wrapper.ts

// AWS SDK v3
expect(putDynamoDb).toHaveBeenCalledWith<[PutCommandInput]>({
  TableName: config.userTableName,
  Item: createdUser,
});
// AWS SDK v2
expect(putDynamoDb).toHaveBeenCalledWith<
  [DynamoDB.DocumentClient.PutItemInput]
>({
  TableName: config.userTableName,
  Item: createdUser,
});

create-user-aws-sdk-v3.ts

export const createUser = async (input: CreateUserInput): Promise<User> => {
  const createdAt = new Date().toISOString();

  const userToCreate: User = {
    id: randomUUID(),
    email: input.email,
    role: input.role,
    createdAt,
    updatedAt: createdAt,
  };

  await dynamoDbDocumentClient.send(
    new PutCommand({
      TableName: config.userTableName,
      Item: userToCreate,
    }),
  );

  return userToCreate;
};

get-users-by-role-aws-sdk-v3.ts

export const getUsersByRole = async (
  role: Role,
): Promise<GetUsersByRoleOutput> => {
  const { Items: users } = await dynamoDbDocumentClient.send(
    new QueryCommand({
      TableName: config.userTableName,
      IndexName: config.userTableRoleIndexName,
      ExpressionAttributeNames: { '#role': 'role' },
      ExpressionAttributeValues: { ':role': role },
      KeyConditionExpression: '#role = :role',
    }),
  );

  if (!maybeUsers) {
    return [];
  }

  return users as User[];
};

get-users-by-role-dynamodb-with-wrapper.ts

export const getUsersByRoleDynamoDb = async (
  role: Role,
): Promise<GetUsersByRoleOutput> => {
  const { Items: users } = await queryDynamoDb({
    TableName: config.userTableName,
    IndexName: config.userTableRoleIndexName,
    ExpressionAttributeNames: { '#role': 'role' },
    ExpressionAttributeValues: { ':role': role },
    KeyConditionExpression: '#role = :role',
  });

  if (!users) {
    return [];
  }

  return users as User[];
};

import-aws-sdk-client-mock-jest.ts

import 'aws-sdk-client-mock-jest';

init-dynamo-client.ts

import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
import { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';

const dynamoDbClient = new DynamoDBClient({ region: 'ap-southeast-2' });

export const dynamoDbDocumentClient =
  DynamoDBDocumentClient.from(dynamoDbClient);

install-aws-sdk-client-mock-jest.sh

yarn add -D aws-sdk-client-mock-jest

install-aws-sdk-client-mock.sh

yarn add -D aws-sdk-client-mock

install-dynamo-deps.sh

yarn add @aws-sdk/client-dynamodb @aws-sdk/lib-dynamodb

mock-client-aws-sdk-client-mock.ts

import { mockClient } from 'aws-sdk-client-mock';

const mockDynamoDbDocumentClient = mockClient(dynamoDbDocumentClient);

mock-dynamodb-file.ts

jest.mock('../../../aws-sdk-v3/dynamodb');

mock-query-wrapper-function.ts

it('should query user by role from dynamodb', async () => {
  const role: Role = 'READER';

  const mockReaderUser: User = {
    ...mockUser,
    role,
  };

  jest.mocked(queryDynamoDb).mockResolvedValue({
    $metadata: {},
    Items: [mockReaderUser],
  });
});

query-dynamodb-aws-sdk-v2-wrapper.ts

export const queryDynamoDb = async (
  params: DynamoDB.DocumentClient.QueryInput,
): Promise<DynamoDB.DocumentClient.QueryOutput> =>
  await dynamoDbDocumentClient.query(params).promise();

query-users-aws-sdk-v2.ts

const { Items: maybeUsers } = await dynamoDbDocumentClient
  .query({
    TableName: config.userTableName,
    IndexName: config.userTableRoleIndexName,
    ExpressionAttributeNames: { '#role': 'role' },
    ExpressionAttributeValues: { ':role': role },
    KeyConditionExpression: '#role = :role',
  })
  .promise();

setup-expected-response-aws-sdk-client-mock.ts

it('should create user with readonly properties and put in dynamodb', async () => {
  mockDynamoDbDocumentClient.on(PutCommand).resolves({});
});

setup-list-users-aws-sdk-client-mock.ts

it('should query user by role from dynamodb', async () => {
  const role: Role = 'READER';

  const mockReaderUser: User = {
    id: 'TestUserId',
    email: 'test@email.com',
    role,
    createdAt: '2023-09-10T05:58:16.945Z',
    updatedAt: '2023-09-10T05:58:16.945Z',
  };

  mockDynamoDbDocumentClient.on(QueryCommand).resolves({
    Items: [mockReaderUser],
  });
});

simplify-to-have-been-called-with.ts

expect(putDynamoDb).toHaveBeenCalledWith<Parameters<typeof putDynamoDb>>({
  TableName: config.userTableName,
  Item: createdUser,
});

unit-test-aws-sdk-v2.ts

it('should query user by role from dynamodb', async () => {
  const mockReaderUser: User = {
    id: 'TestUserId',
    email: 'test@email.com',
    role: 'READER',
    createdAt: '2023-09-10T05:58:16.945Z',
    updatedAt: '2023-09-10T05:58:16.945Z',
  };

  const mockQueryDynamoDb = jest.fn().mockImplementation(() => ({
    promise: jest.fn().mockResolvedValue({ Items: [mockReaderUser] }),
  }));
  jest
    .spyOn(dynamoDbDocumentClient, 'query')
    .mockImplementation(mockQueryDynamoDb);

  await expect(getUsersByRole('READER')).resolves.toEqual([mockReaderUser]);

  expect(mockQueryDynamoDb).toHaveBeenCalledWith<
    [DynamoDB.DocumentClient.QueryInput]
  >({
    TableName: config.userTableName,
    IndexName: config.userTableRoleIndexName,
    ExpressionAttributeNames: { '#role': 'role' },
    ExpressionAttributeValues: { ':role': mockReaderUser.role },
    KeyConditionExpression: '#role = :role',
  });
});

wrap-query-dynamodb.ts

export const queryDynamoDb = async (
  params: QueryCommandInput,
): Promise<QueryCommandOutput> =>
  await dynamoDbDocumentClient.send(new QueryCommand(params));