Mockers - Overcoming Testing Challenges at Grab

Summary

Grab operates over 250 microservices communicating over HTTP and gRPC, making shared staging environments costly, ambiguous in ownership, and fragile due to inconsistent data and uncoordinated deployments. To address these testing bottlenecks, Grab created Mockers, a Go SDK and CLI tool backed by a central monorepo of mock servers for local-box and CI testing. Mockers automatically generates HTTP and gRPC mock servers from Swagger specifications and protobuf files, returning configured network responses without internal business logic. By incorporating Grab's in-house chaos SDK middleware, Mockers also enables repeatable resiliency and contract testing locally without relying on code-level mocks. While Grab still mandates integration testing on distributed staging environments with live data, Mockers enables developers to detect complex defects and contract mismatches earlier.

Context

Testing Grab's ecosystem of over 250 microservices on shared staging environments resulted in high debugging costs, ownership ambiguity, fragile test states, and difficulty testing negative or resilient failure modes.

Approach / What changed

Grab built Mockers, a Go SDK and CLI tool managing a monorepo of mock servers generated directly from Swagger API specs and protobuf definitions to run network-level contract, functional, and chaos tests locally and in CI.

Takeaways

• Mockers creates network-level mock servers from API Swagger specifications or protobuf files instead of requiring developers to inject code-level interface mocks.
• Integrated chaos SDK middleware in Mockers allows local simulation of latency, CPU spikes, memory leaks, and configurable failure percentages to test retries and fallback paths.
• Despite shifting functional and contract tests to local boxes, teams must still maintain staging integration tests to validate against live microservice dependencies, real data, and streaming infrastructure.

Related reading

• Grab · Apr 10, 2019

  Loki, a Dynamic Mock Server for HTTP/TCP Testing

  Grab built Loki, a dynamic mock server written in Golang that simulates backend services on local developer machines and CI pipelines. Mobile app testing previously suffered from heavy dependencies on complex, brittle staging environments and interconnected services communicating over HTTP, HTTPS, and TCP. Loki handles both HTTP and TCP traffic on distinct ports while exposing a unified RESTful API to manage test expectations. It provides runtime flexibility through sandboxed JavaScript execution, configurable request sequence ordering, and an in-memory cron scheduler for TCP push messages. Adopting Loki decoupled mobile releases from staging stability, improving delivery cycles and enabling automated UI testing with Espresso and XCUITest.

  Thuy Nguyen

• Grab · Mar 12, 2026

  Enabling R8 optimization at scale with AI-assisted debugging

  Grab experienced widespread Application Not Responding spikes across its Android superapp, driven by memory pressure and complex Jetpack Compose layouts embedded in legacy code. While switching to advanced R8 optimization promised significant performance gains, obfuscated stack traces and two-hour remote compilation cycles stalled investigation across nine million lines of code. To resolve this, engineers built Model Context Protocol tools to automate APK decompilation, deobfuscation, and code context extraction. The team paired these tools with an AI workflow that used the GitLab CLI to generate multiple solution branches and run verification builds in parallel. This strategy replaced hours of manual reverse engineering with minutes of automated analysis, allowing the team to debug and validate aggressive optimizations at scale.

  Nguyen Van Minh

• Grab · Dec 23, 2019

  Marionette - Enabling E2E User-scenario Simulation

  Conducting end-to-end testing across Grab's transport microservices became difficult due to service availability, environment construction, cross-service authentication, and complex data setups for real-world user accounts. To address these challenges without relying on physical mobile devices or emulators, Grab built Marionette, an internal simulation platform for passenger and driver interactions. The platform provisions required test data, coordinates booking lifecycles, and isolates test executions across distinct user groups using localized cohorts. Engineers can configure driver and passenger behaviors, execute workflows, and run load or integration tests through a dedicated user interface, a Go SDK, and RESTful APIs.

  Anish Jha

• Grab · Apr 18, 2017

  Deep Dive into iOS Automation at Grab - Integration Testing

  Grab replaced third-party cloud CI services with an in-house Xcode Server pipeline to run automated iOS integration tests across an expanding engineering team. Instead of performing fresh repository clones on shared cloud instances, Xcode Server pulls code incrementally and mirrors local developer configurations. The team automated testing bots through Ruby scripts and Arcanist hooks tied to Phabricator code reviews, dynamically provisioning bots on diffs and deleting them after merges. This architecture preserves step-by-step UI test execution logs and screenshots for easier failure diagnostics. To maintain stability on on-premises hardware, pre-integration scripts clear application cache states using simctl commands.

  Sun Xiangxin