[Question]Best practice to mock the database for API tests in Hono? (Runtime: Node, DB: DynamoDB, Test: Bun)

[SeieiSogen]

Hello! I’m looking for best practices to mock/stub the database layer when testing Hono APIs without starting a real server.

• Runtime: Node.js 22
• Hono: v4.9.5
• DB client: DynamoDB
• Test runner: Bun
• Goal: keep tests fast by injecting a mocked repository and calling app.request(...).

describe('GET /users/:id', () => {
  it('returns 200 with user json', async () => {
    // mocking db
    const res = await app.request('http://test/users/42')
    expect(res.status).toBe(200)
    expect(await res.json()).toEqual({ id: '42', name: 'Bremo' })
  })

})

[blockchainGuru1018]

Got it! You want to test Hono routes in Node + Bun without hitting a real DynamoDB instance and without starting a real HTTP server. The key is to inject a mock repository or mock the database client at the function layer. Here’s a best-practice approach:

1. Structure Your Code for Dependency Injection

Instead of tightly coupling your Hono route to DynamoDB, abstract your DB access behind a repository interface:
// src/repositories/userRepo.ts
export interface UserRepo {
  getUserById(id: string): Promise<{ id: string; name: string } | null>
}

// src/repositories/dynamoUserRepo.ts
import { DynamoDBClient, GetItemCommand } from '@aws-sdk/client-dynamodb'

export class DynamoUserRepo implements UserRepo {
  constructor(private client: DynamoDBClient) {}

  async getUserById(id: string) {
    // actual DynamoDB call
    return { id, name: 'Real User' } // simplified
  }
}

2. Inject Repository into Hono App

// src/app.ts
import { Hono } from 'hono'
import type { UserRepo } from './repositories/userRepo'

export function createApp(userRepo: UserRepo) {
  const app = new Hono()

  app.get('/users/:id', async (c) => {
    const user = await userRepo.getUserById(c.req.param('id'))
    if (!user) return c.json({ error: 'Not found' }, 404)
    return c.json(user)
  })

  return app
}

✅ This allows swapping the real DynamoDB repo with a mock repo in tests.

3. Create a Mock Repository for Tests

// tests/mocks/mockUserRepo.ts
import type { UserRepo } from '../../src/repositories/userRepo'

export class MockUserRepo implements UserRepo {
  private users = [{ id: '42', name: 'Bremo' }]

  async getUserById(id: string) {
    return this.users.find(u => u.id === id) ?? null
  }
}

4. Write the Test Without Starting a Server
With Bun and Hono, you can directly call app.request():

// tests/users.test.ts
import { describe, it, expect } from 'bun:test'
import { createApp } from '../src/app'
import { MockUserRepo } from './mocks/mockUserRepo'

describe('GET /users/:id', () => {
  const app = createApp(new MockUserRepo())

  it('returns 200 with user json', async () => {
    const res = await app.request('http://test/users/42')
    expect(res.status).toBe(200)
    expect(await res.json()).toEqual({ id: '42', name: 'Bremo' })
  })

  it('returns 404 for unknown user', async () => {
    const res = await app.request('http://test/users/99')
    expect(res.status).toBe(404)
  })
})

✅ Advantages:

1. No network overhead – you don’t start a real HTTP server.
2. Fast – tests run entirely in-memory.
3. Flexible – can swap different mocks for different test scenarios.
4. Safe – no risk of touching real DynamoDB.

5. Optional: Mock AWS SDK

If you want to test the repository itself without hitting DynamoDB, you can also mock @aws-sdk/client-dynamodb methods using vi.fn() (from vitest) or Bun’s built-in mocks.

TL;DR

• Abstract DB operations behind a repository interface.
• Inject either a mock repo or a real repo into your Hono app.
• Call app.request() directly in Bun tests.
• Optionally, mock AWS SDK if testing the repository layer.

If you want, I can provide a full example with DynamoDBClient mocked so that even your repo can be tested without touching AWS. That way, all layers stay isolated.

[polRk]

If your app has many dependencies, the createApp call will end up with a long list of required properties—most of which aren’t actually needed for a particular test.

[polRk]

The simple way (without extra code) is mock modules directly.
https://vitest.dev/guide/mocking.html
https://bun.com/docs/test/mocks
nodejs/node#42242