44 Mocking Database untuk Test Resolver: Panduan Lengkap dengan Contoh dan Diagram

Sebagai engineer, kita tahu bahwa pengujian adalah salah satu tahap terpenting dalam siklus hidup pengembangan aplikasi. Ketika berbicara tentang arsitektur modern seperti GraphQL ataupun REST, bagian resolver (entah itu di backend Node.js, atau framework lain) memiliki peran vital sebagai jembatan logika bisnis dengan database. Nah, masalahnya, testing resolver seringkali ribet karena harus me-manage dependensi database. Di sinilah konsep mocking database sangat powerful.

Dalam artikel ini, saya akan membahas “44 Mocking Database untuk Test Resolver”, mulai dari pengantar, strategi, implementasi dengan berbagai tools populer, hingga simulasi kode nyata. Tujuannya adalah memberi panduan komprehensif yang bisa kamu terapkan langsung saat menulis unit dan integration test untuk resolver di project-mu.

Mengapa Mocking Database untuk Resolver?

Problem Sebenarnya

Tes unit idealnya harus deterministic, cepat, dan tidak tergantung pada eksternal. Kalau setiap kali testing resolver harus query database beneran, proses testing bisa jadi lambat, data tidak konsisten, serta debugging-nya ribet.

Misal, kamu punya resolver GraphQL seperti ini:

const resolvers = {
  Query: {
    user: async (_, { id }, { dataSources }) => {
      return dataSources.userAPI.getUserById(id);
    },
  }
};

Kalau userAPI benar-benar call ke database, bagaimana kalau data test sudah berubah? Atau database sedang down? Maka mocking database jadi solusi.

44 Cara Mocking Database

1. Manually Mock Data Source (Tanpa Library)

Paling sederhana adalah langsung override function yang akses DB, ganti dengan function yang return data dummy.

const mockUser = { id: 1, name: 'John Doe' };

const dataSources = {
  userAPI: {
    getUserById: jest.fn().mockReturnValue(mockUser),
  },
};

test('should fetch user from mocked database', async () => {
  const response = await resolvers.Query.user(null, { id: 1 }, { dataSources });
  expect(response).toEqual(mockUser);
});

2. Menggunakan Library JesTest/Jest (Mocking dan Spying)

Jest sangat powerful untuk mocking fungsi database dan memang sering digunakan di ekosistem JavaScript/TypeScript.

jest.mock('../db', () => ({
  getUserById: jest.fn().mockResolvedValue({ id: 1, name: "Jane Doe" }),
}));

3. In-Memory Databases (SQLite, MongoMemoryServer)

Jika perlu test integrasi tapi tak ingin connect ke DB sesungguhnya, gunakan DB versi memory.

const { MongoMemoryServer } = require('mongodb-memory-server');
const mongoose = require('mongoose');

let mongoServer;

beforeAll(async () => {
  mongoServer = await MongoMemoryServer.create();
  const uri = mongoServer.getUri();
  await mongoose.connect(uri);
});

afterAll(async () => {
  await mongoose.connection.close();
  await mongoServer.stop();
});

4. Libraries Mock Database

Ada banyak library third-party yang siap pakai untuk mocking database, seperti:

Simulasi: Mocking Database untuk GraphQL Resolver

Kita ambil contoh concrete. Misal aplikasi Blog dengan GraphQL, resolver getPost(id) yang fetch post dari database. Berikut diagram alur test-nya menggunakan Mermaid:

flowchart TD
    A[Test Call getPost(id)] --> B[Resolver getPost]
    B --> C[DataSource: postAPI]
    C --> D[Mocked DB Function]
    D --> E[Return Mocked Data]
    B --> F[Response to Test]

1. Struktur Resolver

// postResolver.js
const resolvers = {
  Query: {
    post: async (_, { id }, { dataSources }) => {
      return dataSources.postAPI.getPostById(id);
    }
  }
};

2. Mock postAPI

Kita siapkan mock function, misal dengan Jest:

// postResolver.test.js
const resolvers = require('./postResolver');

const mockPost = {
  id: "post-44",
  title: "Mocking Database untuk Test Resolver",
  content: "Panduan lengkap mengenal dan menggunakan mocking database."
};

const dataSources = {
  postAPI: {
    getPostById: jest.fn().mockResolvedValue(mockPost)
  }
};

test('should return mocked post data', async () => {
  const post = await resolvers.Query.post(null, { id: 'post-44' }, { dataSources });
  expect(post).toEqual(mockPost);
  expect(dataSources.postAPI.getPostById).toHaveBeenCalledWith('post-44');
});

Hasil outputnya:

PASS  ./postResolver.test.js
✓ should return mocked post data (5 ms)

3. Tabel Simulasi Test

44 Teknik Mocking yang Layak Dicoba

Sebagai engineer, mencapai “44 Mocking Database” bukan berarti literal ada 44, tapi filosofi bahwa mocking sangat bervariasi dan kaya fitur. Berikut beberapa ‘shortcut’ populer:

1. Manual override property pada objek koneksi database.
2. Menggunakan dependency injection untuk ganti instance DB.
3. Pakai environment variable supaya test menggunakan in-memory DB.
4. Jest.fn() atau sinon.stub().
5. Test double pada function DB menggunakan library seperti ts-mockito.
6. Pakai ORM mock (sequelize-mock, TypeORM fake connection).
7. Auto-mock code DB pakai fasilitas di Jest/Babel.
8. Inline mock implementation pada test resolver.
9. Use-case-based mock (test skenario gagal/sukses). 10-44. Kombinasi dari semua teknik di atas (parameter berbeda, case invalid, async/await, error handling, dsb).

Tips Praktis

• Fokus pada isolasi: Pastikan resolver tidak benar-benar menyentuh layanan eksternal.
• Combine mock and spy: Gunakan spy untuk memverifikasi interaksi dengan mock.
• Test error path juga: Mock DB function untuk throw error, lalu tes apakah resolver handle error dengan tepat.
• Untuk integration test, gunakan in-memory atau container DB (Testcontainers).

Penutup

Mocking database untuk test resolver adalah bagian krusial agar engineering process tetap robust, reliable, dan developer-friendly. Dengan memahami berbagai metode dan tools untuk mocking, kamu bisa menulis test yang lebih maintainable dan scalable.

Silakan eksplorasi cara-cara di atas, modifikasi untuk kebutuhan tim kamu, dan jangan lupa selalu update dengan tools terbaru. Ingat, tujuan kita bukan sekadar menulis test, tapi menulis test yang benar-benar menjaga kualitas aplikasi. Happy testing! 🚀

Apakah kamu punya teknik mocking database andalan selain di atas? Share di komentar!