Imagina que decides abrir una pollería. 🐔🔥 Has preparado tu local, tienes el letrero de The Rustic Chicken, el delantal bien puesto y muchas ganas de vender. Pero hay un pequeño problema… ¡todavía no tienes pollos! 😱

Entonces, para no perder tiempo, decides usar pollos de juguete 🐤 para practicar cómo atender clientes, anotar pedidos y simular la experiencia de la venta real. Así, cuando lleguen los pollos de verdad, estarás listo para cocinar y vender como un profesional.

Pues bien, Mockoon hace lo mismo, pero con APIs. 😃

🛠️ Mockoon en pocas palabras

Mockoon es una herramienta que te permite crear servidores falsos en tu computadora. Es como un robot que responde a las peticiones de tus aplicaciones, pero sin necesidad de conectarte a una API real.

💡 Dicho de otra manera: Si una app necesita comunicarse con un servidor para obtener datos (como usuarios, productos o mensajes), en lugar de esperar a que el servidor real esté listo, Mockoon te permite crear uno de mentiritas y responderle a la app como si fuera real.

📱 ¿Cómo ayuda en el desarrollo de apps móviles?

Si eres desarrollador de apps móviles, seguro que más de una vez te ha pasado esto:

🔴 "La API no está lista, no puedo probar nada"**
🟡 "El backend está caído y mi app no funciona"**
🟢 "Me gustaría probar qué pasa si la API responde con error"

Aquí es donde entra Mockoon como un superhéroe. 🦸

✅ Puedes crear respuestas personalizadas sin depender de que la API real esté funcionando.
✅ Te permite probar diferentes escenarios, como respuestas correctas, errores o datos vacíos.
✅ Funciona en modo offline, así que no necesitas internet para simular la API.

En resumen: Con Mockoon, tu app puede seguir avanzando incluso si el backend está en construcción o tiene problemas. 🚀

📥 Instalando Mockoon en tu computadora###

¡Bienvenido al segundo paso de nuestro viaje! 🚀 Ahora que ya sabes qué es Mockoon, toca instalarlo en tu computadora para empezar a jugar con servidores falsos. Vamos a hacerlo paso a paso, como si estuviéramos cocinando un Pollo Campero a la brasa. 🔥🐔

1️⃣ Ir a la página oficial de Mockoon

Antes de cocinar cualquier plato, necesitamos los ingredientes. En este caso, el ingrediente principal es Mockoon. Para descargarlo, ve a su página web oficial:

🔗 https://mockoon.com/

Verás una pantalla con algo así como:

Pulsa sobre el botón Download y navegarás a la siguiente pantalla

Selecciona el método de instalación que más te convenga, y procede con la instalación.

2️⃣Abrir Mockoon por primera vez

Ahora que ya tienes Mockoon instalado, ¡es hora de abrirlo!

🔥 Un entorno vacío esperando que crees tu primer servidor falso.

Creando un nuevo entorno (servidor falso)

Piensa en un "entorno" en Mockoon como tu pollería digital. Aquí definirás qué tipo de pedidos acepta y qué tipo de respuestas sirve.

🍗 Para crear un nuevo entorno:

1. En la parte superior izquierda de Mockoon, haz clic en el símbolo ➕ y a continuación pulsa en botón "New local enviroment".
2. Pon el nombre que quieras, por ejemplo "Polleria API".
3. Cámbiale el nombre a "Pollería API" para que tenga más personalidad.

Ahora verás que el entorno tiene un número de puerto asignado (por defecto, 3000). Este es como el horno donde se cocinarán nuestras respuestas API. 🔥

💡 Consejo: Puedes cambiar el puerto si ya tienes algo corriendo en el 3000. Simplemente edítalo en el menú de settings bajo el apartado API URL.

Creando nuestro primer endpoint

Un endpoint es como un mostrador de la pollería. 🏪 Es donde los clientes (las apps) hacen sus pedidos y esperan una respuesta.

🍗 Para agregar un nuevo endpoint en Mockoon:

1. En la barra lateral izquierda, busca el botón "New route" ➕ y haz clic en él.
2. Selecciona HTTP router
3. Se creará una ruta con el nombre GET /.
4. Cámbiale el nombre a /pollos (esto significa que cuando alguien pida /pollos, responderemos con información sobre pollos).
5. En la parte derecha, donde dice "Body", cambia el contenido por este JSON:

{  
  "pollos": \[  
    { "id": 1, "nombre": "Pollo Campero", "precio": 10.99 },  
    { "id": 2, "nombre": "Pollo Asado", "precio": 12.99 }  
  \]  
}

Entendiendo los conceptos clave

📌 Endpoints y rutas:

• Son las direcciones donde las apps hacen sus pedidos.

• En este caso, /pollos es un endpoint.

📌 Métodos HTTP:**
**Los métodos son como los tipos de pedido que un cliente puede hacer. Los más comunes son:

• GET 👉 Para pedir información (Ej: “Dame los pollos disponibles”).

• POST 👉 Para enviar datos nuevos (Ej: “Quiero agregar un pollo al menú”).

• PUT 👉 Para actualizar algo (Ej: “Cambia el precio del Pollo Campero”).

• DELETE 👉 Para eliminar algo (Ej: “Quita el Pollo Asado del menú”).

📌 Respuestas JSON:

• Los servidores suelen responder en JSON, que es como una carta de menú digital.

• En nuestro ejemplo, el JSON devuelve una lista de pollos con sus nombres y precios.

---

🥳 ¡Y eso es todo! Acabas de crear tu primer servidor falso con Mockoon. 🚀

Ahora, en el siguiente paso, aprenderemos a probarlo y ver si realmente funciona. Así que ponte el delantal, que esto empieza a oler a pollo API recién hecho. 🐔🔥

🍗 ¡Sirviendo respuestas! Creando una respuesta JSON en Mockoon

Bien, polluelo cibernético, ya creaste tu primer servidor falso y ahora toca aprender a preparar las respuestas. Vamos a hacer que Mockoon nos devuelva datos en formato JSON, como si estuviéramos sirviendo un plato de pollo con guarnición. 🐔🔥

1️⃣ Creando una respuesta con JSON

Mockoon nos permite definir qué responderá nuestro servidor cuando alguien haga una petición. Vamos a hacer que nuestra API de pollos devuelva una lista de productos en formato JSON.

🍗 Pasos para definir una respuesta JSON:

1. Asegúrate de que tienes un entorno creado (si no, revisa el punto anterior).
2. En la barra lateral izquierda, selecciona la ruta /pollos.
3. En la parte derecha, busca la sección "Body" y cambia el contenido a:

{
  "pollos": [
    { "id": 1, "nombre": "Pollo Campero", "precio": 10.99 },
    { "id": 2, "nombre": "Pollo Asado", "precio": 12.99 },
    { "id": 3, "nombre": "Alitas Picantes", "precio": 8.99 }
  ]
}

4. Guarda los cambios y asegúrate de que el servidor esté encendido.

¡Listo! Ahora cuando alguien haga una petición a http://localhost:3000/pollos, recibirá esta lista de pollos en formato JSON. 🚀

🚦 Códigos de estado HTTP (200, 404, 500...) y Rules

Cuando una app hace una petición a una API, esta responde con un código de estado HTTP. Es como cuando en la pollería te dicen:

✅ "Aquí tienes tu pedido" (200 OK)**
❌ "No hay más pollos" (404 Not Found)
**💥 "Se incendió la parrilla" (500 Internal Server Error)

🔢 Los códigos más comunes en una API:

• 200 OK 🟢 → Todo salió bien, aquí está tu pollo.

• 201 Created 🟢 → El pollo fue agregado con éxito al menú.

• 400 Bad Request 🟠 → Pediste algo mal, revisa tu orden.

• 401 Unauthorized 🟠 → No tienes permiso para pedir pollo aquí.

• 404 Not Found 🔴 → Ese pollo no existe.

• 500 Internal Server Error 🔴 → Algo explotó en la cocina.

🍗 Definir un código de estado 401 usando una Rule para nuestra Response

1. Ve a la ruta /pollos que creaste.
2. Agregamos otra Response pulsando sobre el símbolo ➕. Esto nos creará la Response 2.
3. Cambiamos el status de la Response 2  a 401 (Unauthorized).
4. Ahora pulsamos sobre Rules y agregamos una nueva Rule pulsando sobre ➕.
5. La condición de la Rule será que no exista en la cabecera de la petición la key Authorization con el value Bearer polloToken123. En ese caso se cumplirá la rule y se mostrará el 401.
6. Pulsamos sobre Status & Body y ponemos este JSON para ser devuelto en el error si se cumple la rule.

{
  "error": {
    "code": 401,
    "message": "Unauthorized",
    "details": "No tienes permisos para acceder a este recurso. Por favor, verifica tus credenciales e inténtalo de nuevo."
  }
}

Ahora llamaremos al endpoint pollos, enviando en el header la key Authorization, y veremos como nos responde con un 200 y los datos apropiados.

A continuación volveremos a llamar a llamar al endpoint 200 pero sin enviar en la cabecera de la petición la key Authorization, y nos devuelve el código de error 401

¡Ahora tu servidor ya sabe cómo responder con distintos estados usando rules! 🚀

🎲 Uso de variables dinámicas en Mockoon

¿Y si queremos que los datos sean dinámicos, como nombres aleatorios o fechas actuales? ¡Fácil! Mockoon tiene "helpers" que permiten generar valores aleatorios.

🔀 Ejemplo: Generar nombres aleatorios de pollos

1. Ve a la ruta /pollos.

En la sección "Body", cambia el JSON a:

[
  {{#repeat 5}}
    {
      "id": "{{faker 'string.uuid'}}",
      "nombre": "{{faker 'commerce.productName'}}",
      "descripcion": "{{faker 'commerce.productDescription'}}",
      "precio": "{{faker 'commerce.price' 1 1000 2 '€'}}",
      "disponible": {{faker 'datatype.boolean'}}
    }
  {{/repeat}}
]

2. Guarda los cambios y prueba la API.

🔍 Análisis línea por línea

  {{#repeat 5}}

🔹 {{#repeat 5}} → Es una directiva de Handlebars que le dice a Mockoon:

• "Repite este bloque 5 veces".
• En otras palabras, Mockoon generará 5 objetos automáticamente.

"id": "{{faker 'string.uuid'}}",

🔹 "id" → Clave que representa un identificador único para cada objeto.
🔹 {{faker 'string.uuid'}} → Usa Faker.js para generar un UUID (identificador único universal).

Ejemplo de salida: "id": "550e8400-e29b-41d4-a716-446655440000"

	"nombre": "{{faker 'commerce.productName'}}",

🔹 "nombre" → Clave que representa el nombre del pollo.
🔹 {{faker 'commerce.productName'}} → Usa Faker.js para generar un nombre de producto aleatorio.

Ejemplo de salida: "nombre": "Pollo Teriyaki Deluxe"

	"descripcion": "{{faker 'commerce.productDescription'}}",

🔹 "descripcion" → Clave que describe el objeto con un texto aleatorio.
🔹 {{faker 'commerce.productDescription'}} → Faker.js generará una descripción de producto aleatoria.

Ejemplo de salida: "descripcion": "Un delicioso pollo asado con especias naturales y un toque de limón."

"precio": "{{faker 'commerce.price' 1 1000 2 '€'}}",

🔹 "precio" → Clave que representa el precio del pollo.
🔹 {{faker 'commerce.price' 1 1000 2 '€'}} → Genera un precio aleatorio entre 1 y 1000, con 2 decimales y la moneda €.

• Ejemplo de salida: "precio": "15.99€"

"disponible": {{faker 'datatype.boolean'}}

🔹 "disponible" → Clave que indica si el pollo está disponible o no.
🔹 {{faker 'datatype.boolean'}} → Faker.js generará un valor true o false de manera aleatoria.

• Ejemplo de salida: "disponible": true

Cada vez que hagas una petición, ¡los nombres y precios cambiarán! 🎲🎉

📌 Otros ejemplos de variables dinámicas en Mockoon:

• Fecha actual: {{date 'YYYY-MM-DD'}}

• Número aleatorio: {{randomInt 1 100}}

• Texto aleatorio: {{faker.lorem.sentence}}

Ahora tu API puede responder con datos dinámicos y realistas. 🚀🔥

🎯 RESUMEN FINAL

 ✅ Generamos 5 objetos automáticamente con datos aleatorios.
✅ Cada pollo tiene un id**,** nombre**,** descripcion**,** precio y disponible.
✅ Mockoon y Faker.js nos permiten simular una API real con respuestas dinámicas.
✅ Cada vez que hagas una petición, ¡los nombres y precios cambiarán! 🔄🐔💸

Así que cada vez que tu aplicación llame a este endpoint, tendrás pollos diferentes con precios distintos. ¡Es como un menú del día digital! 🍗😄

📡 Integrando Mockoon con tus proyectos

Una vez que tienes tu servidor de pollos virtual funcionando, necesitas que tu aplicación lo use en lugar de una API real. Esto es útil cuando el backend aún no está listo o cuando quieres trabajar de manera independiente.

Cómo apuntar tu aplicación a Mockoon en lugar de una API real

Cuando Mockoon está en ejecución, genera una URL local, como:

http://localhost:3000

Para que tu aplicación use Mockoon en lugar de un servidor real, cambia la URL de la API en tu código:

🔧 Ejemplo en Kotlin (Android Retrofit):

interface ApiService {
    @GET("/pollos")
    suspend fun obtenerPollos(): List<Pollo>
}

val retrofit = Retrofit.Builder()
    .baseUrl("http://localhost:3000/") // Apunta a Mockoon
    .addConverterFactory(GsonConverterFactory.create())
    .build()

💡 Consejo: Puedes usar variables de entorno para cambiar entre Mockoon y la API real fácilmente. 

Recuerda que el dispositivo móvil o emulador debe estar conectado a la misma red que mockoon(Por wifi por ejemplo)

Uso de Mockoon en equipos de desarrollo

Si trabajas en equipo, Mockoon es una herramienta ideal porque permite que todos usen la misma API falsa sin necesidad de un backend.

✅ Ventajas de usar Mockoon en equipo:

• Cada desarrollador puede trabajar sin depender de los cambios del backend.

• Puedes probar cómo responde la app sin necesidad de conexión a internet.

• Los testers pueden validar la aplicación con diferentes escenarios antes de que el backend esté listo.

📝 Guardando y compartiendo tu configuración

Después de haber configurado un servidor de pollos perfecto, es importante guardar y compartir esta configuración con tu equipo.

📤 Exportar un entorno (guardar tu configuración)

Si quieres compartir tu API simulada con otros, puedes exportarla siguiendo estos pasos:

1. Abre Mockoon y selecciona el entorno que deseas exportar.
2. Haz clic en los tres puntos (el icono de más opciones) al lado del entorno que quieres exportar.
3. Selecciona la opción "Show data file in Explorer/Finder".
4. Se abrirá una ventana que mostrará el archivo .json del entorno seleccionado.
5. Copia el archivo y pégalo en la ubicación donde quieras guardarlo.
   • Si lo deseas, puedes renombrarlo, pero asegúrate de mantener la extensión .json.

✨ ¡Listo! Ahora tienes un archivo OpenAPI que puedes compartir con tu equipo.

💡 Consejo: Puedes subir la configuración a GitHub para que el equipo siempre tenga la última versión.

📥 Importar un entorno (cargar una configuración existente)

Si alguien te envió un archivo con una configuración de Mockoon en OpenAPI, puedes importarlo fácilmente:

1. Abre Mockoon.
2. En la barra lateral, haz clic en el símbolo "+" para agregar un nuevo entorno.
3. En el menú que aparece, selecciona la opción "Open local environment".
4. Se abrirá un explorador de archivos. Navega hasta la ruta donde tienes el archivo .json o .yaml que deseas importar.
5. Selecciona el archivo que quieres importar.
6. Pulsa sobre el botón "Abrir".

✨ ¡Listo! Ahora tu entorno será cargado en Mockoon y podrás comenzar a usarlo de inmediato.

💡 Consejo: Puedes importar múltiples entornos y tener varios servidores simulados al mismo tiempo.

Con esto, ahora puedes compartir tu API falsa como un profesional y asegurarte de que todo tu equipo usa la misma configuración. ¡Nada de excusas para que los pollos no funcionen en la app! 🐔🚀

🐔⏳ Simular la velocidad de respuesta del servicio

A veces, tenemos tanto trabajo que no servimos los pedidos con la suficiente velocidad. ¡Pobres clientes! Están esperando con hambre, mirando el reloj, y deseando que esos exquisitos Pollos Camperos asados lleguen más rápido. Pero, como en todo negocio, ¡a veces hay un poquito de lag!

¿Qué podemos hacer? ¡No te preocupes! Mockoon tiene la solución para simular ese "lag" en nuestras respuestas y ver cómo reacciona el sistema. 

¿Cómo simularlo?

1. En Mockoon, selecciona el endpoint donde quieres aplicar el lag (en nuestro caso, puede ser el endpoint donde le servimos un delicioso Pollo Campero).
2. Haz clic sobre el icono del reloj.

Introduce la cantidad de milisegundos (ms) que quieres que tarde en enviarse la respuesta.

Por ejemplo, si le ponemos 2000 ms (2 segundos), la respuesta del servidor se retrasará por 2 segundos antes de llegar al cliente. Así, nuestros pobres clientes pueden ver cómo el pollo tarda un poquito más en llegar a sus manos. ¡Un poquito de paciencia, que la espera vale la pena! 🍗⏳

¿Por qué es útil?

Simular este lag en la respuesta es ideal para hacer pruebas, por ejemplo:

• Comprobar cómo actúa tu sistema si la respuesta tarda más de lo esperado.

• Ver animaciones de carga (loader) mientras la respuesta llega (¡como el que espera pacientemente su pollo en el restaurante!).

• Probar cómo reacciona tu app si no recibe la respuesta después de cierto tiempo, por ejemplo, si el cliente tiene que esperar mucho o si la aplicación necesita manejar un timeout (que es como cuando el pollo tarda más de la cuenta y el cliente se pone impaciente 😅).

Así, ¡serás capaz de ver cómo tu aplicación se comporta en escenarios donde el lag es el rey del día! ¡Y de paso, practicarás cómo servir un pollo con más calma (o no)! 🐔💨

🛠️ Creando un CRUD desde 0 🐔📡

¡Venga, ahora vamos a ponernos serios! 😎
Vamos a crear todo un CRUD desde cero en Mockoon. Un CRUD es lo mínimo que necesitas para gestionar datos en una API, permitiendo Crear (Create), Leer (Read), Actualizar (Update) y Eliminar (Delete) información. ¡Vamos a hacerlo con pollos! 🐔🔥

📌 Paso 1: Crear un nuevo entorno

Lo primero que necesitamos es un nuevo environment donde trabajaremos.

1. Abre Mockoon.
2. Pulsa el símbolo "+" para crear un nuevo environment.
3. Ponle un nombre épico como: "API de Pollos".

📌 Paso 2: Crear un CRUD en Mockoon

Para que nuestra API de pollos tenga todas las operaciones CRUD, vamos a hacer lo siguiente:

1. Ve a la pestaña "Routes".
2. Pulsa el símbolo "+" para añadir una nueva ruta.
3. Selecciona la opción "CRUD route".
4. Dale el nombre de "pollos".
5. Indica que vamos a filtrar en el CRUD por el id

Esto nos generará automáticamente las rutas necesarias para manejar nuestros pollos con los métodos:

✅ GET /pollos → Obtener la lista de pollos.
✅ POST /pollos → Agregar un nuevo pollo.
✅ GET /pollos/:id → Obtener un pollo por su ID.
✅ PUT /pollos/:id → Actualizar un pollo.
✅ DELETE /pollos/:id → Eliminar un pollo.

📌 Paso 3: Crear la base de datos de pollos 🐣

Ahora vamos a introducir los datos con los que trabajará nuestro CRUD.

1. Ve a la pestaña "Data".
2. Pulsa sobre el símbolo "+" para crear un nuevo dataset.
3. Introduce el siguiente JSON en la sección de datos y ponle de nombre "Pollos Data":

[
  {
    "id": 1,
    "nombre": "Plumitas",
    "edad": 3,
    "deGranja": true,
    "categoria": "A"
  },
  {
    "id": 2,
    "nombre": "Pío",
    "edad": 5,
    "deGranja": false,
    "categoria": "B"
  },
  {
    "id": 3,
    "nombre": "Cocoroco",
    "edad": 2,
    "deGranja": true,
    "categoria": "A"
  },
  {
    "id": 4,
    "nombre": "Gallina",
    "edad": 7,
    "deGranja": true,
    "categoria": "C"
  },
  {
    "id": 5,
    "nombre": "Pollito",
    "edad": 1,
    "deGranja": false,
    "categoria": "B"
  }
]

📌 Explicación de los datos:

• id → Identificador único del pollo. 🆔
• nombre → Nombre del pollo. 🐔
• edad → Edad del pollo en años. 📆
• deGranja → Si el pollo viene de una granja (true o false). 🚜
• categoría → Clasificación del pollo (A, B o C). 🎖️

🧙‍♂️ ¡Pero qué brujería es esta! 🔥🐔

Con solo estos pasos hemos creado un CRUD completamente funcional.
¡Mockoon nos ha hecho la vida demasiado fácil! 😱✨

Ahora toca probarlo en acción. Pero antes de hacer nada...

🛑 ¡Recuerda arrancar el servidor en Mockoon!**
🔹 Para ello, pulsa el botón de Play ▶️ en la parte superior.
🔹 Mockoon abrirá el servidor en http://localhost:3000.

📜 1️⃣ Listar los pollos actuales

Ejecuta esta petición en tu terminal:

curl -s http://localhost:3000/pollos/ | jq

Obtenemos la siguiente salida:

[
  {
    "id": 1,
    "nombre": "Plumitas",
    "edad": 3,
    "deGranja": true,
    "categoria": "A"
  },
  {
    "id": 2,
    "nombre": "Pío",
    "edad": 5,
    "deGranja": false,
    "categoria": "B"
  },
  {
    "id": 3,
    "nombre": "Cocoroco",
    "edad": 2,
    "deGranja": true,
    "categoria": "A"
  },
  {
    "id": 4,
    "nombre": "Gallina",
    "edad": 7,
    "deGranja": true,
    "categoria": "C"
  },

  {
    "id": 5,
    "nombre": "Pollito",
    "edad": 1,
    "deGranja": false,
    "categoria": "B"
  }
]

➕ 2️⃣ Crear un nuevo pollo

Ahora vamos a añadir un nuevo pollo a nuestra lista. 🐔🔥

📌 Haz una petición POST ejecutando este comando en tu terminal:

curl -X POST -H "Content-Type: application/json" -d '{
  "nombre": "Nugget",
  "edad": 2,
  "deGranja": true,
  "categoria": "B"
}' http://localhost:3000/pollos

Si todo va bien, Mockoon responderá con el nuevo pollo creado. ✅

{"nombre":"Nugget","edad":2,"deGranja":true,"categoria":"B","id":6}

Volvemos a listar el listado de pollos, y hemos de ver con el siguiente id el nuevo pollo creado, nuestro delicioso Nugget:

curl -s http://localhost:3000/pollos/ | jq

[
  {
    "id": 1,
    "nombre": "Plumitas",
    "edad": 3,
    "deGranja": true,
    "categoria": "A"
  },
  {
    "id": 2,
    "nombre": "Pío",
    "edad": 5,
    "deGranja": false,
    "categoria": "B"
  },
  {
    "id": 3,
    "nombre": "Cocoroco",
    "edad": 2,
    "deGranja": true,
    "categoria": "A"
  },
  {
    "id": 4,
    "nombre": "Gallina",
    "edad": 7,
    "deGranja": true,
    "categoria": "C"
  },
  {
    "id": 5,
    "nombre": "Pollito",
    "edad": 1,
    "deGranja": false,
    "categoria": "B"
  },
  {
    "nombre": "Nugget",
    "edad": 2,
    "deGranja": true,
    "categoria": "B",
    "id": 6
  }
]

👀 R E A D: Encontrando a nuestro pollo perdido 🐔🔍

¡Es hora de poner a prueba el Read de nuestro CRUD!
Vamos a buscar a un polluelo en específico, concretamente al que tiene el ID 3.
¿Quién será...? 🤔

🔎 1️⃣ Buscando al pollo con ID 3

Abrimos una terminal y escribimos:

curl -s http://localhost:3000/pollos/3 | jq

⏳ Mockoon buscará en su corral de datos... y nos responderá con:

{
  "id": 3,
  "nombre": "Cocoroco",
  "edad": 2,
  "deGranja": true,
  "categoria": "A"
}

🕵️‍♂️ ¡Ajá! ¡Así que el pollo Cocoroco estaba escondido tras el ID 3!

🐔 Cocoroco es un pollito joven, de solo 2 añitos.
🏡 Vive en una granja, y además, pertenece a la categoría A.
🎩 ¡Un pollo con clase!

🔹 Este método es ideal para buscar un pollo en concreto sin tener que recorrer toda la lista.

📌 Bonus: ¿Y si buscamos un ID que no existe?

Si buscamos un ID que no está en nuestra base de datos, por ejemplo el 99:

curl -s http://localhost:3000/pollos/99 | jq

Nos devolverá

{}

Se puede configurar un Response para devolviera un mensaje o dato en concreto que queramos para un code 404 Not Found

¡Genial! Ya hemos probado el Read.

¿Qué tal si ahora pasamos al Update para modificar algún pollito? 🛠️🐔

🛠️ U P D A T E: ¡Plumitas ha crecido! 🎉🐔

🎊 ¡Qué alegría, qué alboroto! ¡Nuestro querido Plumitas ha cumplido un añito más! 🎂🐣
Ahora ya no tiene 3 años, sino 4.
Es hora de actualizar su edad y dejarlo bien registrado en nuestra API.

📜 1️⃣ Listamos la información actual de Plumitas

Antes de hacer cambios, vamos a ver cómo está registrado ahora mismo.
Abrimos una terminal y ejecutamos:

curl -s http://localhost:3000/pollos/1 | jq

👀 Mockoon nos devuelve:

{
  "id": 1,
  "nombre": "Plumitas",
  "edad": 3,
  "deGranja": true,
  "categoria": "A"
}

🧐 Efectivamente, Plumitas tenía 3 años... ¡hasta hoy!

Vamos a corregir este dato, que ya es un pollo más grande.

📝 2️⃣ Actualizamos la edad de Plumitas a 4 años

Para actualizarlo, ejecutamos el siguiente comando en la terminal:

curl -X PUT -H "Content-Type: application/json" -d '{
  "nombre": "Plumitas",
  "edad": 4,
  "deGranja": true,
  "categoria": "A"
}' http://localhost:3000/pollos/1

🔄 Mockoon nos responde confirmando el cambio:

{
  "nombre": "Plumitas",
  "edad": 4,
  "deGranja": true,
  "categoria": "A",
  "id": 1
}

🎩 ¡Ajá! Ahora sí, Plumitas tiene 4 años oficialmente!

📜 3️⃣ Comprobamos que el cambio se haya guardado

Volvemos a listar a Plumitas para verificar que la actualización se hizo correctamente:

curl -s http://localhost:3000/pollos/1 | jq

👀 Mockoon responde con:

{
  "nombre": "Plumitas",
  "edad": 4,
  "deGranja": true,
  "categoria": "A",
  "id": 1
}

🎉 ¡Mira qué orgulloso está Plumitas ahora que su edad es la correcta! 🐔💪

🛠️ Ahora ya sabemos actualizar los datos de un pollo!

¿Qué sigue? Borrar a un pollo de nuestra base de datos... 😱

¿Nos atrevemos a probar el DELETE? 🔥

🍲 D E L E T E: Adiós Gallina, gracias por tu servicio 😢🐔

😳 No me mires así...
Esto es un restaurante y uno de nuestros clientes ha pedido sopa de gallina.
No nos queda más remedio que sacrificar a Gallina…

👀 1️⃣ Confirmamos que Gallina sigue en nuestra base de datos

Antes de despedirnos de nuestra querida Gallina, asegurémonos de que sigue ahí:

curl -s http://localhost:3000/pollos/4 | jq

📜 Mockoon nos responde:

{
  "id": 4,
  "nombre": "Gallina",
  "edad": 7,
  "deGranja": true,
  "categoria": "C"
}

💡 Efectivamente, Gallina sigue entre nosotros.

🗑️ 2️⃣ Eliminamos a Gallina del listado

💀 Es el momento...**
**Con un solo comando, Gallina pasará a la historia (y a la olla 🥘):

curl -X "DELETE" "http://localhost:3000/pollos/4"

⚠️ Mockoon no nos dice nada...

El silencio es abrumador. Pero es la señal de que Gallina ya no está con nosotros.

🔎 3️⃣ Verificamos que Gallina ha desaparecido

Para asegurarnos de que Mockoon la ha eliminado, volvamos a buscarla:

curl -s http://localhost:3000/pollos/4 | jq

👀 Mockoon responde:

{}

❌ Gallina ya no está en la base de datos.

💔 Hasta siempre, Gallina...

💬 "Gallina, fuiste una parte importante de nuestra pollería. Alimentaste a muchos, fuiste fiel compañera en nuestros menús, pero ahora... ahora eres un caldo reconfortante. Gracias por todo. Descansa en paz (o en sopa) 🥣."

🐔 Fin de la historia de Gallina.

🔥 ¡Y con esto terminamos nuestro viaje por Mockoon! 🔥

Ahora tienes una base sólida para seguir explorando todos los secretos que esta maravillosa herramienta ofrece. 🕵️‍♂️🔍

Recuerda que puedes experimentar, romper cosas y arreglarlas. Porque así es como se aprende de verdad. 💪😎

🌟 Que la fuerza del Pollo Campero te acompañe… SIEMPRE. 🐔💫