title: 90 Strategi Pengujian dan CI/CD GraphQL-Go: Panduan Komprehensif untuk Engineer Backend
subtitle: Langkah demi langkah mengamankan kualitas dan keandalan API GraphQL berbasis Golang
date: 2024-06-11
author: engineer.medium

Pendahuluan

API GraphQL menjadi primadona dalam membangun layanan backend yang scalable dan mantap performanya. Apalagi jika kita mengimplementasikannya di Go (graphql-go), kita mendapat kombinasi efisiensi dan type safety tingkat dewa.

Namun, membangun API saja tidak cukup. Kita butuh strategi pengujian (Testing) dan Continuous Integration/Continuous Delivery (CI/CD) yang solid agar perubahan kode tetap terjamin kualitasnya. Artikel ini akan membedah 90 strategi pengujian dan CI/CD untuk proyek graphql-go. Tak lupa, saya sertakan potongan kode, simulasi proses, tabel, dan diagram Mermaid untuk visualisasi.

Rangkaian Pengujian untuk graphql-go

Mari mulai dengan skema besar proses pengujian, dari paling mendasar hingga yang kompleks:

flowchart TD
    A(Unit Test) --> B(Integration Test)
    B --> C(Contract Test)
    C --> D(Schema Validation)
    D --> E(Security Test)
    E --> F(Load Test)
    F --> G(E2E Test)

flowchart TD
    A(Unit Test) --> B(Integration Test)
    B --> C(Contract Test)
    C --> D(Schema Validation)
    D --> E(Security Test)
    E --> F(Load Test)
    F --> G(E2E Test)

Sederhananya: Unit ➜ Integration ➜ Contract ➜ Schema ➜ Security ➜ Load ➜ End-to-End.

1. Strategi Unit Testing (15+)

Unit test berfokus pada simpul-simpul terkecil: resolver dan fungsi utility. Contoh:

 1func TestHelloResolver(t *testing.T) {
 2    r := NewResolver()
 3    got, err := r.Hello(context.Background(), nil)
 4    if err != nil {
 5        t.Fatalf("expected no error, got %v", err)
 6    }
 7    if got != "Hello, world!" {
 8        t.Fatalf("got %v, want 'Hello, world!'", got)
 9    }
10}

• Mock dependency eksternal (DB, HTTP, Cache)
• Uji semua cabang logika
• Tes error handling secara eksplisit
• Gunakan table-driven test
• Isolir side effect

2. Strategi Integration Testing (15+)

Integration test menguji komponen-komponen yang saling terhubung, misal resolver + DB.

1func TestUserQuery_Integration(t *testing.T) {
2    db := InitTestDB()
3    defer db.Cleanup()
4    r := NewResolverWithDB(db)
5    got, err := r.User(context.Background(), &UserArgs{ID: "abc123"})
6    if err != nil || got.Name != "Budi" {
7        t.Fatalf("unexpected: %v, %+v", err, got)
8    }
9}

Strategi lanjutan:

• Injeksi dependency mock
• Setup dan teardown data
• Simulasi kegagalan jaringan/DB

3. Contract Testing (10+)

Pastikan server GraphQL konsisten dengan spesifikasi schema:

1gql-contract-tester --schema schema.graphql --endpoint http://localhost:8080/graphql

Tips:

• Simpan snapshot schema pada tiap PR
• Gunakan schema diff tools
• Cek resolabilitas semua query/mutation utama

4. Schema Validation & Codegen (10+)

Validasi schema memastikan breaking change tidak “ngumpet”.

1# Validasi schema
2gqlint schema.graphql
3
4# Code generation: Go struct dari schema
5gqlgen generate

Dengan auto-codegen, banyak bug teratasi sejak tahap compile-time.

5. Security Testing (10+)

Simulasikan query injection, invalid input, dan introspeksi tak diinginkan.

Contoh pengujian depth-limit:

1func TestDepthLimit(t *testing.T) {
2    // Coba query nested terlalu dalam
3    query := `{ user { friends { friends { friends { name }}}}}`
4    resp := DoGraphQLRequest(query)
5    if resp.HasError("exceeds max depth") == false {
6        t.Errorf("should block deep nested query")
7    }
8}

6. Load & Performance Testing (10+)

Uji beban query GraphQL dan latency response.

Tools: k6 , Gatling, Vegeta.

Contoh skrip k6:

1import http from "k6/http";
2export default function () {
3  http.post("http://localhost:8080/graphql", JSON.stringify({ query: "{users{name}}" }));
4}

Monitoring latency, error rate, dan resources secara otomatis.

7. End-to-End Testing (10+)

Uji seluruh flow user: frontend ➜ backend ➜ DB ➜ frontend.

Tools: Cypress, Playwright, Postman.

Contoh custom E2E dengan Go:

1func TestE2E_UserFlow(t *testing.T) {
2    server := StartTestServer()
3    defer server.Shutdown()
4    token := LoginAndGetToken()
5    req := MakeAuthenticatedGraphQLRequest(token, `{me{name}}`)
6    if resp := req.Do(); resp.Data["me"]["name"] != "Budi" {
7        t.Fatalf("E2E fail: %+v", resp)
8    }
9}

Strategi CI/CD untuk graphql-go

CI/CD adalah penenang developer: push kode, otomatis build, testing, deploy.

flowchart LR
    A[Push to GitHub] --> B{Lint & Build}
    B --> C(UnitTests)
    C --> D(IntegrationTests)
    D --|Pass|--> E[Contract/Schema Test]
    E --|Pass|--> F[Deploy to Staging]
    F --|Manual Approve|--> G[Deploy to Production]

flowchart LR
    A[Push to GitHub] --> B{Lint & Build}
    B --> C(UnitTests)
    C --> D(IntegrationTests)
    D --|Pass|--> E[Contract/Schema Test]
    E --|Pass|--> F[Deploy to Staging]
    F --|Manual Approve|--> G[Deploy to Production]

8. Github Actions/CI Pipeline (10+)

Sample .github/workflows/ci.yml:

 1name: GraphQL Go CI
 2
 3on: [push, pull_request]
 4
 5jobs:
 6  build-and-test:
 7    runs-on: ubuntu-latest
 8
 9    steps:
10      - uses: actions/checkout@v3
11
12      - name: Set up Go
13        uses: actions/setup-go@v3
14        with:
15          go-version: 1.22
16
17      - name: Lint
18        run: go vet ./...
19
20      - name: Build
21        run: go build ./...
22
23      - name: Unit tests
24        run: go test -v -short ./...
25
26      - name: Integration tests
27        run: go test -v -tags=integration ./...
28
29      - name: Schema validation
30        run: gqlint schema.graphql
31
32      - name: Contract test
33        run: gql-contract-tester --schema schema.graphql --endpoint http://localhost:8080/graphql

9. Otomatisasi Deployment (5+)

Integrasi otomatis Docker & deployment ke cloud (Kubernetes/Heroku/etc):

1- name: Build Docker image
2  run: docker build -t registry.io/project/graphql-go:$GITHUB_SHA .
3
4- name: Push to registry
5  run: docker push registry.io/project/graphql-go:$GITHUB_SHA
6
7- name: Deploy to k8s
8  run: kubectl set image deployment/graphql-go graphql-go=registry.io/project/graphql-go:$GITHUB_SHA

Manfaatkan environment staging sebelum approval ke production.

Simulasi: Workflow CI/CD dengan 90 Strategi

Apa jadinya jika semua strategi dijalankan secara terstruktur? Berikut simulasi alur:

Total: 90+ strategi komplementer.

Penutup

Mengimplementasikan 90 strategi pengujian dan CI/CD bukan sekadar “testing”, tapi cara berpikir sebagai engineer production-grade. Dengan praktik terbaik mulai dari unit, integrasi, kontrak, hingga beban dan keamanan, didukung pipeline CI/CD yang otomatis—kita mampu menjaga GraphQL API Go tetap solid, secure, dan easy to ship.

Sudah siap level-up?
Terapkan strategi di atas ke proyek mu dan selamat menikmati ketenangan deploy minggu malam!

Referensi:

• graphql-go
• Go Testing Techniques
• Contract Test Tools for GraphQL
• GQLGen Codegen
• Securing GraphQL APIs