TL;DR — Mock servers como WireMock (15+ millones de descargas), Mockoon y json-server permiten a los equipos móviles desarrollar y testear sin backend. Esta guía cubre configuración, integración Android/iOS, CI/CD y patrones avanzados.

Los servidores mock son herramientas esenciales para el desarrollo móvil, permitiendo a los equipos desarrollar y probar aplicaciones antes de que las APIs backend estén listas. Según la documentación de WireMock, la herramienta ha acumulado más de 15 millones de descargas y la usan miles de equipos en todo el mundo. Una encuesta de SmartBear sobre API mocking encontró que el 71% de los equipos que usan mocks reportan ciclos de desarrollo más rápidos y menos problemas de integración. Estas herramientas eliminan el problema de “bloqueados por el backend” que retrasa los releases móviles en toda la industria.

“Configurar un mock server es una de las primeras cosas que hago al unirme a un proyecto móvil nuevo. Desbloquea al equipo de inmediato y fuerza una mentalidad contract-first que da frutos a lo largo de todo el ciclo de desarrollo.” — Yuri Kan, Senior QA Lead

Por Qué Importan los Mock Servers para Desarrollo Móvil

Beneficios Clave

  1. Desarrollo Paralelo: Equipos frontend y backend trabajan independientemente
  2. Testing Offline: Desarrollar sin conectividad a internet
  3. Simulación de Casos Extremos: Probar escenarios de error, rate limiting, timeouts
  4. Datos de Prueba Consistentes: Entornos de prueba reproducibles
  5. Integración CI/CD: Tests automatizados rápidos y confiables
  6. Reducción de Costos: Sin infraestructura backend necesaria para desarrollo local

Escenario Real 

Sin Mock Server:

- API backend retrasada 3 semanas
- Equipo móvil bloqueado
- Problemas de integración descubiertos tarde
- Testing depende de entorno staging compartido

Con Mock Server:

- Equipo móvil empieza inmediatamente
- Contrato definido por adelantado
- Casos extremos probados temprano
- Pipelines CI paralelos
- Problemas de integración detectados durante desarrollo

Soluciones Populares de Mock Server

Tabla Comparativa

CaracterísticaWireMockMockoonjson-serverMSW
Complejidad SetupMediaBajaMuy BajaBaja
ConfiguraciónJava/JSONGUI/JSONJSONJavaScript
Coincidencia RequestAvanzadaBuenaBásicaAvanzada
Templating RespuestaHandlebarsHandlebarsEstáticaDinámica
Modo ProxySíSíNoSí
Record & ReplaySíNoNoSí
Integración CIExcelenteBuenaExcelenteExcelente
Mejor ParaAPIs complejasSetup rápidoPrototipadoApps basadas en navegador

WireMock: La Solución Empresarial

Instalación y Configuración

Docker (recomendado para CI/CD móvil):

# Ejecutar contenedor WireMock
docker run -d \
  --name wiremock \
  -p 8080:8080 \
  -v $(pwd)/wiremock:/home/wiremock \
  wiremock/wiremock:latest

JAR Standalone:

# Descargar WireMock
wget https://repo1.maven.org/maven2/org/wiremock/wiremock-standalone/3.3.1/wiremock-standalone-3.3.1.jar

# Ejecutar WireMock
java -jar wiremock-standalone-3.3.1.jar --port 8080

Ejemplos de Configuración

Stub Básico (wiremock/mappings/get-user.json):

{
  "request": {
    "method": "GET",
    "urlPathPattern": "/api/users/([0-9]+)"
  },
  "response": {
    "status": 200,
    "headers": {
      "Content-Type": "application/json"
    },
    "jsonBody": {
      "id": "{{request.pathSegments.[2]}}",
      "username": "juan_perez",
      "email": "juan@ejemplo.com",
      "avatar": "https://cdn.ejemplo.com/avatar.jpg",
      "createdAt": "2024-01-15T10:30:00Z"
    },
    "transformers": ["response-template"]
  }
}

Templating Avanzado de Respuesta:

{
  "request": {
    "method": "POST",
    "url": "/api/orders",
    "headers": {
      "Content-Type": {
        "equalTo": "application/json"
      }
    }
  },
  "response": {
    "status": 201,
    "headers": {
      "Content-Type": "application/json",
      "Location": "/api/orders/{{randomValue type='UUID'}}"
    },
    "jsonBody": {
      "orderId": "{{randomValue type='UUID'}}",
      "status": "pendiente",
      "createdAt": "{{now format='yyyy-MM-dd HH:mm:ss'}}",
      "items": "{{jsonPath request.body '$.items'}}",
      "total": "{{jsonPath request.body '$.total'}}"
    },
    "transformers": ["response-template"]
  }
}

Simulación de Errores:

{
  "scenarioName": "Rate Limiting",
  "requiredScenarioState": "Started",
  "newScenarioState": "Rate Limited",
  "request": {
    "method": "GET",
    "url": "/api/products"
  },
  "response": {
    "status": 429,
    "headers": {
      "Content-Type": "application/json",
      "Retry-After": "60"
    },
    "jsonBody": {
      "error": "rate_limit_exceeded",
      "message": "Demasiadas peticiones. Intente de nuevo más tarde.",
      "retryAfter": 60
    }
  }
}

Simulación de Latencia de Red:

{
  "request": {
    "method": "GET",
    "url": "/api/slow-endpoint"
  },
  "response": {
    "status": 200,
    "fixedDelayMilliseconds": 3000,
    "jsonBody": {
      "message": "Esta respuesta fue retrasada 3 segundos"
    }
  }
}

Integración Android 

// app/build.gradle.kts
dependencies {
    // WireMock para tests instrumentados
    androidTestImplementation("com.github.tomakehurst:wiremock-jre8:2.35.0")
}

// Setup AndroidTest
class WireMockTest {
    private lateinit var wireMockServer: WireMockServer

    @Before
    fun setup() {
        wireMockServer = WireMockServer(
            WireMockConfiguration.options()
                .port(8080)
                .notifier(ConsoleNotifier(true))
        )
        wireMockServer.start()
        WireMock.configureFor("localhost", 8080)
    }

    @After
    fun tearDown() {
        wireMockServer.stop()
    }

    @Test
    fun testUserFetch() {
        // Configurar stub
        stubFor(
            get(urlEqualTo("/api/users/123"))
                .willReturn(
                    aResponse()
                        .withStatus(200)
                        .withHeader("Content-Type", "application/json")
                        .withBody("""
                            {
                              "id": 123,
                              "username": "usuario_prueba",
                              "email": "prueba@ejemplo.com"
                            }
                        """.trimIndent())
                )
        )

        // Configurar app para usar URL de WireMock
        val apiClient = ApiClient("http://localhost:8080")

        // Ejecutar test
        runBlocking {
            val user = apiClient.getUser(123)
            assertEquals("usuario_prueba", user.username)
        }

        // Verificar que se hizo la petición
        verify(
            getRequestedFor(urlEqualTo("/api/users/123"))
                .withHeader("Accept", equalTo("application/json"))
        )
    }
}

Mockoon: Enfoque GUI-First

Instalación 

# macOS
brew install --cask mockoon

# O descargar desde https://mockoon.com

Configuración

Crear API Mock (vía GUI):

  1. Abrir Mockoon

  2. Crear nuevo entorno: “Mobile API Mock”

  3. Configurar puerto: 3000

  4. Añadir rutas:

    • GET /api/users → Respuesta con array de usuarios
    • POST /api/auth/login → Retornar token JWT
    • GET /api/products → Productos paginados

Configuración Programática (mockoon-data.json):

{
  "uuid": "mobile-api-mock",
  "name": "Mobile API Mock",
  "port": 3000,
  "routes": [
    {
      "uuid": "route-1",
      "method": "get",
      "endpoint": "api/users/:id",
      "responses": [
        {
          "uuid": "response-1",
          "body": "{\n  \"id\": \"{{urlParam 'id'}}\",\n  \"username\": \"{{faker 'internet.userName'}}\",\n  \"email\": \"{{faker 'internet.email'}}\",\n  \"avatar\": \"{{faker 'image.avatar'}}\"\n}",
          "statusCode": 200,
          "headers": [
            {
              "key": "Content-Type",
              "value": "application/json"
            }
          ]
        }
      ]
    },
    {
      "uuid": "route-2",
      "method": "post",
      "endpoint": "api/auth/login",
      "responses": [
        {
          "uuid": "response-2",
          "body": "{\n  \"token\": \"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.{{faker 'random.alphaNumeric' 50}}\",\n  \"expiresIn\": 3600,\n  \"user\": {\n    \"id\": \"{{faker 'random.uuid'}}\",\n    \"email\": \"{{body 'email'}}\"\n  }\n}",
          "statusCode": 200
        }
      ]
    }
  ]
}

Uso CLI (para CI/CD):

# Instalar Mockoon CLI
npm install -g @mockoon/cli

# Ejecutar mock server
mockoon-cli start --data ./mockoon-data.json --port 3000

# Ejecutar en background
mockoon-cli start --data ./mockoon-data.json --daemon-name mobile-mock

json-server: Prototipado Rápido

Instalación y Configuración 

# Instalar globalmente
npm install -g json-server

# O como dependencia dev
npm install --save-dev json-server

Crear Base de Datos Mock (db.json):

{
  "users": [
    {
      "id": 1,
      "username": "juan_perez",
      "email": "juan@ejemplo.com",
      "role": "admin"
    },
    {
      "id": 2,
      "username": "maria_garcia",
      "email": "maria@ejemplo.com",
      "role": "user"
    }
  ],
  "posts": [
    {
      "id": 1,
      "userId": 1,
      "title": "Primer Post",
      "content": "¡Hola mundo!",
      "createdAt": "2024-01-15T10:00:00Z"
    }
  ],
  "comments": [
    {
      "id": 1,
      "postId": 1,
      "userId": 2,
      "text": "¡Gran post!",
      "createdAt": "2024-01-15T11:00:00Z"
    }
  ]
}

Rutas Personalizadas (routes.json):

{
  "/api/*": "/$1",
  "/api/users/:id/posts": "/posts?userId=:id",
  "/api/posts/:id/comments": "/comments?postId=:id"
}

Ejecutar Servidor:

# Básico
json-server --watch db.json --port 3000

# Con rutas personalizadas
json-server --watch db.json --routes routes.json --port 3000

# Con simulación de delay
json-server --watch db.json --delay 1000

Integración CI/CD

La integración de servidores mock en pipelines CI/CD permite testing automatizado rápido y confiable. Para frameworks de testing de APIs basados en Java como REST Assured, WireMock proporciona integración perfecta con configuración mínima. Las pruebas móviles modernas en iOS y Android dependen cada vez más de estas integraciones.

GitHub Actions con WireMock 

# .github/workflows/mobile-tests.yml
name: Mobile Tests

on: [push, pull_request]

jobs:
  android-tests:
    runs-on: ubuntu-latest

    services:
      wiremock:
        image: wiremock/wiremock:latest
        ports:

          - 8080:8080
        volumes:

          - ${{ github.workspace }}/wiremock:/home/wiremock

    steps:

      - uses: actions/checkout@v3

      - name: Configurar WireMock stubs
        run: |
          cp -r test-fixtures/wiremock/* wiremock/

      - name: Configurar JDK
        uses: actions/setup-java@v3
        with:
          distribution: 'temurin'
          java-version: '17'

      - name: Ejecutar Tests Android
        run: |
          ./gradlew connectedAndroidTest \
            -Dapi.base.url=http://localhost:8080

Mejores Prácticas

1. Desarrollo Contract-First

Define contratos API (OpenAPI/Swagger) antes de implementación. Genera stubs mock desde contratos. Este enfoque se alinea perfectamente con testing de contratos API para aplicaciones móviles, asegurando que los equipos frontend y backend permanezcan sincronizados.

2. Control de Versiones para Configs Mock 

project/
├── wiremock/
│   ├── mappings/
│   │   ├── users.json
│   │   └── products.json
│   └── __files/
│       └── large-response.json
└── .gitignore (excluir __files para archivos grandes)

3. Configuraciones Específicas por Entorno 

// Android BuildConfig
android {
    buildTypes {
        debug {
            buildConfigField("String", "API_BASE_URL", "\"http://localhost:8080\"")
        }
        release {
            buildConfigField("String", "API_BASE_URL", "\"https://api.production.com\"")
        }
    }
}

4. Datos Realistas con Faker

Usa integración Faker.js de Mockoon o templating de respuesta WireMock:

{
  "username": "{{faker 'internet.userName'}}",
  "avatar": "{{faker 'image.avatar'}}",
  "createdAt": "{{faker 'date.past'}}"
}

Conclusión

Los mock servers son indispensables para el desarrollo móvil moderno:

  • WireMock: Mejor para APIs empresariales complejas, CI/CD, testing de contratos
  • Mockoon: Ideal para setup rápido, flujo basado en GUI, colaboración en equipo
  • json-server: Perfecto para prototipado, APIs CRUD simples, demos rápidas

Elige según las necesidades de tu equipo, infraestructura existente y requisitos de complejidad. Combina múltiples soluciones cuando sea apropiado—usa json-server para prototipado, luego migra a WireMock para testing de grado producción.

Próximos Pasos:

  1. Configura un mock server para tu proyecto actual
  2. Integra con pipeline CI/CD
  3. Crea configuraciones mock reutilizables
  4. Establece flujo de testing de contratos API

Ver También

Preguntas Frecuentes

¿Qué es un mock server en desarrollo móvil? Un mock server simula respuestas de API backend para que los equipos móviles puedan desarrollar y probar apps sin un servidor real. Permite desarrollo paralelo, testing offline y datos de prueba reproducibles.

WireMock vs Mockoon vs json-server — ¿cuál usar? Usá WireMock para APIs enterprise complejas con escenarios stateful y CI/CD; Mockoon para configuración rápida vía GUI; json-server para prototyping y APIs CRUD simples.

¿Cómo integro un mock server en CI/CD? Ejecutá WireMock o Mockoon CLI como servicio Docker en GitHub Actions, configurá la app para usar la URL del mock y corré los tests contra él. Los configs van en control de versiones junto a los fixtures de prueba.

¿Funcionan los mock servers con tests de Android e iOS? Sí. WireMock tiene una librería Android para pruebas instrumentadas. Para iOS, ejecutá WireMock en Docker y apuntá XCTest a localhost:8080. Mockoon CLI funciona en cualquier plataforma vía npm.

Recursos Oficiales

See Also