¿Qué es httpYac?

Si has buscado httpYac, probablemente quieres una forma de enviar peticiones HTTP desde archivos de texto plano que puedas mantener en Git, ejecutar dentro de VS Code, y reproducir en CI. httpYac es exactamente eso: un ejecutor de archivos .http/.rest que se presenta tanto como una extensión de VS Code como una herramienta de línea de comandos de Node.js. Esta guía explica cómo funciona, muestra un pequeño ejemplo, cubre cuándo encaja y señala una interfaz gráfica de usuario (GUI) más una ruta de CI cuando superes los archivos de texto. Para una base más amplia en la disciplina, consulta nuestra guía de pruebas de API.

Qué es realmente httpYac

httpYac es un cliente HTTP de código abierto construido alrededor del formato de archivo .http. Escribes las peticiones como texto plano y luego las envías con una pulsación de tecla en el editor o con un solo comando en tu terminal. El proyecto reside en GitHub y tiene documentación completa en httpyac.github.io.

La idea principal es sencilla. Una petición reside en un archivo de texto junto a tu código. Lo versionas con Git. Lo revisas en una pull request. Lo ejecutas de la misma manera, ya seas un humano en un editor o un trabajo de CI en un servidor de compilación. Ese modelo git-nativo de texto plano es la mayor fortaleza de httpYac, y es la razón por la que muchos desarrolladores backend lo eligen.

La herramienta se compone de dos partes:

• La extensión de VS Code (httpYac) te proporciona un "Send Request" code lens encima de cada petición, vistas previas de respuestas y cambio de entorno dentro del editor.
• La CLI (httpyac, instalada vía npm) ejecuta los mismos archivos de forma desatendida. Eso es lo que la hace compatible con CI: los archivos que probaste localmente son los archivos que ejecuta tu pipeline.

Debido a que ambas superficies leen los mismos archivos .http, no hay un paso de exportación separado. Lo que confirmas es lo que se ejecuta.

El formato de archivo .http

Un archivo .http es una lista de peticiones separadas por ###. Cada petición se lee casi como el HTTP raw que envía. Aquí tienes un pequeño ejemplo.

### Get a user
GET https://api.example.com/users/42
Accept: application/json

### Create a user
# @name createUser
POST https://api.example.com/users
Content-Type: application/json

{
  "name": "Ada Lovelace",
  "email": "ada@example.com"
}

### Use a value from the previous response
GET https://api.example.com/users/{{createUser.response.body.$.id}}
Authorization: Bearer {{token}}

Aquí están ocurriendo varias cosas. Las líneas ### dividen las peticiones. El comentario # @name nombra una petición para que puedas referenciar su respuesta más tarde. Los marcadores de posición {{...}} insertan variables, incluyendo valores encadenados de respuestas anteriores. Este formato se comparte con la popular extensión REST Client, por lo que los archivos a menudo se mueven entre los dos con pequeñas ediciones.

Variables y entornos

httpYac lee variables de archivos .env, de un archivo http-client.env.json y de definiciones en línea dentro del propio archivo de petición. Puedes mantener un conjunto de valores para local, otro para staging y otro para producción, y luego cambiar entre ellos sin editar la petición.

@host = https://api.staging.example.com

### Login
# @name login
POST {{host}}/auth/login
Content-Type: application/json

{ "user": "{{USERNAME}}", "pass": "{{PASSWORD}}" }

Los secretos permanecen en archivos .env que mantienes fuera de Git, por lo que el propio archivo de petición es seguro para confirmar. En CI, las mismas variables provienen de variables de entorno o secretos del pipeline.

Scripting y aserciones

Aquí es donde httpYac va más allá de un simple enviador de peticiones. Puedes incrustar JavaScript en una petición para configurar datos antes de que se ejecute o para verificar la respuesta después. Los bloques pre-petición y post-petición se ejecutan en un contexto de Node, por lo que puedes calcular una firma, almacenar un token o hacer aserciones sobre el cuerpo.

### Login and capture token
# @name login
POST {{host}}/auth/login
Content-Type: application/json

{ "user": "{{USERNAME}}", "pass": "{{PASSWORD}}" }

{{
  // post-request script
  test("status is 200", () => {
    client.assert.strictEqual(response.statusCode, 200);
  });
  exports.token = response.parsedBody.token;
}}

Ese token capturado estará entonces disponible para la siguiente petición como {{token}}. El modelo de scripting es flexible, lo que es parte del atractivo para los desarrolladores que quieren lógica sin tener que configurar un framework de pruebas completo.

Ejecutando httpYac en CI

La CLI es el puente entre "funciona en mi máquina" y "se ejecuta en el pipeline". Instálala y apúntala a tus archivos.

npm install -g httpyac

# Run a single file
httpyac send api/users.http

# Run every request in a folder, pick an environment, fail on assertion errors
httpyac send --all --env staging "api/**/*.http"

httpYac sale con un código de error distinto de cero cuando falla una aserción, que es lo que necesita un trabajo de CI para marcar una compilación en rojo. Puede emitir una salida de estilo JUnit para los reporteros de pruebas, de modo que los resultados aparecen en tu panel de CI en lugar de quedar enterrados en los registros. Coloca ese comando en GitHub Actions, GitLab CI o Jenkins, y los mismos archivos que editaste en VS Code ahora protegen tus fusiones.

Cuándo usar httpYac

httpYac se adapta a un tipo específico de equipo y flujo de trabajo. Úsalo cuando la mayoría de estas afirmaciones sean ciertas.

Es menos adecuado cuando personas no desarrolladoras necesitan ejecutar o editar peticiones, cuando deseas una vista visual de grandes colecciones de peticiones, cuando necesitas entornos compartidos y sincronización de equipo sin configurar archivos, o cuando deseas informes más completos y pruebas de carga en un solo lugar. La ergonomía del texto plano es una característica hasta que el conjunto crece y el equipo se amplía.

httpYac vs. una GUI y plataforma de CI

httpYac es un ejecutor de archivos de texto. Apidog es un modelo diferente: una plataforma de API con GUI que también se ejecuta en CI. Ninguno es "mejor" en abstracto; resuelven el problema desde extremos opuestos. Seamos claros desde el principio: Apidog no ejecuta ni analiza de forma nativa archivos .http. Si tu fuente de verdad es una carpeta de archivos .http, httpYac los ejecuta directamente, y esa es su ventaja honesta.

Así es como se comparan los dos en los aspectos que suelen decidir la elección.

Si deseas el aspecto visual, Apidog te permite construir y organizar peticiones sin escribir archivos a mano, y luego ejecutar los mismos escenarios en CI con apidog run. La referencia del comando apidog run detalla el comando, las banderas de entorno y los reporteros. También obtienes un servidor de mocking y documentación en el mismo espacio de trabajo, algo que un ejecutor de archivos de texto deja a otras herramientas. Si el mocking es una necesidad real, nuestro resumen de herramientas de mocking de endpoints REST cubre las opciones.

El resumen honesto: httpYac gana cuando todo tu flujo de trabajo es "archivos en Git, ejecutar en el editor, reproducir en CI" y tu equipo está compuesto íntegramente por desarrolladores. Apidog gana cuando quieres un espacio de trabajo visual compartido, entornos gestionados, mocking y documentación junto con ejecuciones de CI. Algunos equipos incluso usan ambos, con httpYac para comprobaciones locales rápidas y Apidog como fuente de verdad del equipo.

Preguntas frecuentes

¿Es httpYac gratuito?

Sí. httpYac es de código abierto bajo la licencia MIT. Tanto la extensión de VS Code como la CLI son gratuitas para instalar y usar. No hay un nivel de pago ni un requisito de cuenta para ejecutar peticiones localmente o en CI.

¿En qué se diferencia httpYac de la extensión REST Client?

Ambos utilizan el mismo formato de archivo .http, por lo que los archivos son en gran medida portables. httpYac añade una CLI independiente para ejecuciones sin interfaz gráfica y en CI, un manejo de entornos más amplio y un modelo de scripting y aserciones más rico. REST Client es solo para el editor. Si solo envías peticiones dentro de VS Code, cualquiera de los dos funciona; si necesitas ejecutar los mismos archivos en un pipeline, la CLI de httpYac es el diferenciador. Para una visión más amplia de las herramientas del editor, consulta nuestra lista de plugins de VS Code para pruebas de API.

¿Puede httpYac reemplazar a Postman?

Para un desarrollador que quiere peticiones de texto plano en Git y ejecuciones de CI, httpYac cubre mucho de lo que la gente usa Postman, menos la GUI, las colecciones compartidas y el mocking incorporado. Si tu equipo necesita un espacio de trabajo visual, entornos gestionados y mocking juntos, una plataforma como Apidog se ajusta más. Compara opciones en nuestro resumen de clientes de pruebas de API.

¿httpYac es compatible con GraphQL y gRPC?

httpYac maneja peticiones GraphQL y varios protocolos más allá de REST simple, incluyendo algunos casos de streaming. Consulta la documentación oficial para ver la lista actual de protocolos, ya que el soporte evoluciona entre lanzamientos. Para REST, el formato .http cubre los verbos, cabeceras, cuerpos y flujos de autenticación comunes de forma predeterminada.

Conclusión

httpYac es una respuesta clara a una necesidad clara: enviar peticiones HTTP desde archivos de texto plano, ejecutarlas en VS Code y reproducirlas en CI sin un paso de exportación separado. Su modelo git-nativo, el scripting y la CLI gratuita lo convierten en una opción sólida para equipos con muchos desarrolladores que quieren que sus peticiones vivan en el repositorio. La desventaja es que todo asume código, archivos y fluidez del desarrollador.

Si prefieres construir peticiones visualmente, compartir entornos gestionados, simular endpoints y generar documentación mientras sigues ejecutando pruebas en CI, Apidog cubre ese terreno en un solo espacio de trabajo. Puedes descargar Apidog y ejecutar tu suite con apidog run, o mantener httpYac para comprobaciones locales rápidas y dejar que Apidog sea la fuente de verdad del equipo. Elige el modelo que se adapte a la forma en que trabaja tu equipo.