.http 파일과 httpyac

제목 : .http 파일과 httpyac

---

VSCode, IntelliJ 와 같은 IDE 에서는 .http 확장자를 가진 요청 파일을 지원한다.

이 때, 위의 에디터들은 .http 파일에 대한 구문과, 하이라이팅을 지원한다.

뿐만 아니라, 내부의 내장된 Request Agent 가 쿠키와 세션을 유지하여 테스팅이 편리하다.

하지만, 다른 에디터를 사용 할 경우, .http 파일의 실행을 지원하는 플러그인이 없다.

따라서, 로컬 머신에 httpyac 이라는 프로그램을 설치 할 수 있다.

먼저, httpyac 을 이용하기 위해서, 내부에 ### 을 통해 하나의 요청에 대한 주석을 작성해야 한다.

httpyac 은 뭐지?

이는 에디터에서 http 플러그인을 사용하는 대신, Homebrew 와 같은 패키지 매니저를 통해

직접 명령어로 테스팅 할 수 있는 것이다.

나는 Vim 에서 NeoVim 을 사용했고,

NeoVim 에디터의 커스텀으로도 불편 한 점이 많아,

터미널 기능과 에디터의 중간의 위치를 가진 Zed 에디터를 선택했다.

현재는 매우 만족하면서 사용하고 있는데, 문제는 VSCode 나 IntelliJ 처럼

내부 Http Request Agent 를 지원 해 주지 않는다는 것이다.

따라서, 편리한 .http 파일을 사용하기 위해, HttpYac 을 선택했다.

기본적으로, 실행은 이러하다 :

➜  users git:(main) ✗ httpyac requests.http
? please choose which region to use
❯ all
  새로운 유저 생성
  유저 로그인
  주어진 ID 로 특정한 유저 찾기
  whoami 메서드로 요청을 보내 세션을 통한 나를 찾기
  로그아웃
  주어진 email 로 모든 유저 찾기
(Use arrow keys to reveal more choices)

### 새로운 유저 생성
POST http://localhost:3000/auth/signup
content-type: application/json

{
    "email" : "test@gmail.com",
    "password" : "12341234"
}

내부의 .http 파일의 내용을 이렇게 생겼다.

### 을 통해 실행 시, 보여 질 수 있는 제목을 정해놓았다.

body 로 들어 갈 내용을 `{ ... } 로 적을 수 있다.

httpyac CLI 로서의 문제점

문제는, VSCode 나 IntelliJ 와 다르게, Request Agent 로서의 정보를 저장하는 기능이 없다.

즉, 로그인 후 쿠키를 전송하는 행위는 위의 http 파일처럼 작성해서는 전송이 안된다는 것이다.

Request CLI 로 실행 시, 한 번의 실행동안 쿠키나 세션이 유지되고,

완수되고 나면 모든 캐싱 정보들이 사라진다.

httpyac 에서의 Request Agent 캐싱 정보 유지하기

httpyac 공식 홈페이지에서 제공하는 캐싱 유지 방식들이 있긴 한데,

그 이전에 나는 httpyac 에서 지원하는 몇 가지 키워드를 사용했다.

• @name xxxx - 현재 파일, 혹은 외부 파일에서 해당 요청을 참조 할 수 있게 정한다.
• @import ../xxxx.http - `사용하고자 하는 요청이 현재 .http 파일에 없을 경우, 해당 경로에서 가져온다.
• @ref xxxx - 현재 파일, 혹은 외부 파일에서 @name 과 같이 송출된 요청을 먼저 실행한다.

위의 3 가지 키워드를 사용한다면, 로그인 후 자신의 정보를 추출하는 요청이 가능해진다.

한번, 예시를 들어 본다.

users/requests.http

### 유저 로그인
# @name signin
POST http://localhost:3000/auth/signin
content-type: application/json

{
    "email" : "test@gmail.com",
    "password" : "12341234"
}

• @name : 내부 혹은 외부에서 @ref 혹은 @forceRef 로 자신을 요청 할 수 있다.\
• @import : 원하는 요청이 다른 .http 파일에 존재 할 경우, 경로로 가져올 수 있다.
• @ref : 내부 혹은 외부에서 별칭으로 참조 할 수 있는 요청을 가져온다.

reports/request.http

### POST http://localhost:3000/reports
# @import ../users/requests.http
# @ref signin
POST http://localhost:3000/reports
content-type: application/json
{
    "price" : 500000,
    "make" : "toyota",
    "model" : "corolla",
    "year" : 1980,
    "lng" : 0,
    "lat" : 0,
    "mileage" : 100000
}

httpyac 사용법

위에서는 httpyac 을 사용하면서 마주할 수 밖에 없는 문제점에 대해서 설명했다.

그렇다면, 어떻게 사용할까?

위에서 나는 POST http://localhost:3000/auth/signin 를 요청해보자.

➜  users git:(main) ✗ httpyac requests.http
✔ please choose which region to use 유저 로그인

---------------------

=== 유저 로그인 ===
# 요청 본문 시작
POST http://localhost:3000/auth/signin
accept: */*
accept-encoding: gzip, deflate, br
content-length: 63
content-type: application/json
user-agent: httpyac

{
    "email" : "test@gmail.com",
    "password" : "12341234"
} # 요청 본문 종료.
HTTP/1.1 201  - Created # 응답 본문 시작
connection: keep-alive
content-length: 33
content-type: application/json; charset=utf-8
date: Mon, 05 May 2025 14:19:37 GMT
etag: W/"21-nIb9OrtC7n5iRpqXg0Bp/3uF/RA"
keep-alive: timeout=5
set-cookie: session=eyJ1c2VySWQiOjF9; path=/; httponly,session.sig=Assbm1VoBVhl6uJ90YDXls2YHPs; path=/; httponly
x-powered-by: Express

{
  "id": 1,
  "email": "test@gmail.com"
}

1 requests processed (1 succeeded) # 응답 본문 종료.

위에서 볼 수 있듯이, CLI 에 익숙하지 않은 사람은 읽기가 어려울 수 있다.

하지만, 요청 본문과 응답 본문을 전부 볼 수 있다는 점에서 굉장히 유용하다.

그렇다면, 로그인 상태를 필요로 하는 요청을 해 보자

위에서 제시한 POST http://localhost:3000/reports 는 로그인 상태를 기반으로 한다.

즉, 로그인 되지 않는다면 예외가 반환된다.

위에서 보여준 예시는 로그인 상태를 먼저 요청하게 해 주므로,

단순한 하나의 reports 요청을 해 보자.

### POST http://localhost:3000/reports
POST http://localhost:3000/reports
content-type: application/json
{
    "price" : 500000,
    "make" : "toyota",
    "model" : "corolla",
    "year" : 1980,
    "lng" : 0,
    "lat" : 0,
    "mileage" : 100000
}

위에서는 @import, @ref 키워드는 존재하지 않는다.

즉, CLI 단계에서 명령어가 끝난다면, 쿠키와 세션은 종료된다.

➜  reports git:(main) ✗ httpyac requests.http
✔ please choose which region to use POST http://localhost:3000/reports

---------------------

=== POST http://localhost:3000/reports ===

POST http://localhost:3000/reports
accept: */*
accept-encoding: gzip, deflate, br
content-length: 145
content-type: application/json
user-agent: httpyac

{
    "price" : 500000,
    "make" : "toyota",
    "model" : "corolla",
    "year" : 1980,
    "lng" : 0,
    "lat" : 0,
    "mileage" : 100000
}
HTTP/1.1 403  - Forbidden
connection: keep-alive
content-length: 69
content-type: application/json; charset=utf-8
date: Mon, 05 May 2025 14:29:10 GMT
etag: W/"45-MZJWZc+Y+RUbHpnhz2B2Vipii24"
keep-alive: timeout=5
x-powered-by: Express

{
  "message": "Forbidden resource",
  "error": "Forbidden",
  "statusCode": 403
}

1 requests processed (1 succeeded)

위의 요청은 단순히 어떠한 credential 정보도 없이 전송되었다.

쿠키, 캐시, 세션, JWT 등 어떠한 것도 전송되지 않은 것이다.

따라서, 프로그램에 입력된 Guard 에 따라 403(Forbidden)이 반환되었다. (NestJS)

그렇다면, @import, @ref 키워드를 통해 users/ 디렉토리에 존재하는

/users/request.http 파일을 참조 해 보자 :

### POST http://localhost:3000/reports
# @import ../users/requests.http
# @ref signin
POST http://localhost:3000/reports
content-type: application/json
{
    "price" : 500000,
    "make" : "toyota",
    "model" : "corolla",
    "year" : 1980,
    "lng" : 0,
    "lat" : 0,
    "mileage" : 100000
}

➜  reports git:(main) ✗ httpyac requests.http
✔ please choose which region to use POST http://localhost:3000/reports

---------------------

=== 유저 로그인 ===

POST http://localhost:3000/auth/signin
accept: */*
accept-encoding: gzip, deflate, br
content-length: 63
content-type: application/json
user-agent: httpyac

{
    "email" : "test@gmail.com",
    "password" : "12341234"
}
HTTP/1.1 201  - Created
connection: keep-alive
content-length: 33
content-type: application/json; charset=utf-8
date: Mon, 05 May 2025 14:31:55 GMT
etag: W/"21-nIb9OrtC7n5iRpqXg0Bp/3uF/RA"
keep-alive: timeout=5
set-cookie: session=eyJ1c2VySWQiOjF9; path=/; httponly,session.sig=Assbm1VoBVhl6uJ90YDXls2YHPs; path=/; httponly
x-powered-by: Express

{
  "id": 1,
  "email": "test@gmail.com"
}

---------------------

=== POST http://localhost:3000/reports ===

POST http://localhost:3000/reports
accept: */*
accept-encoding: gzip, deflate, br
content-length: 145
content-type: application/json
cookie: session=eyJ1c2VySWQiOjF9; session.sig=Assbm1VoBVhl6uJ90YDXls2YHPs
user-agent: httpyac

{
    "price" : 500000,
    "make" : "toyota",
    "model" : "corolla",
    "year" : 1980,
    "lng" : 0,
    "lat" : 0,
    "mileage" : 100000
}

HTTP/1.1 201  - Created
connection: keep-alive
content-length: 130
content-type: application/json; charset=utf-8
date: Mon, 05 May 2025 14:31:55 GMT
etag: W/"82-w4pyzgCUzmyC/qLHjFocf3p6bmg"
keep-alive: timeout=5
x-powered-by: Express

{
  "id": 3,
  "price": 500000,
  "year": 1980,
  "lng": 0,
  "lat": 0,
  "make": "toyota",
  "model": "corolla",
  "mileage": 100000,
  "approved": false,
  "userId": 1
}

2 requests processed (2 succeeded)

users/request.http 파일의 signin 을 통해 로그인 세션을 가져 올 수 있다.

그런데, 위의 내용이 너무 긴 것을 볼 수 있다.

이유는 실제로 @ref 하는 과정에서, signin 요청을 실행 한 뒤,

이후로 POST reports 했기 때문이다. 이러한 결과는 가독성을 해치는 결과를 낳는다.

---

httpyac 에서 쿠키 캐싱하기

httpyac 은 실제 NodeJS 구문 기반의 scripting 을 지원한다.

아주 간단한 예시를 들자면,

{{
    console.log("Test Script");
}}
GET http://localhost:3000/users
.....

위와 같은 형식으로 JavaScript 와 상호작용할 수 있다.

그리고 만약에 request 혹은 response 에 간섭하고 싶다면,

{{@request
    request.headers['Cookie'] = ....
}}
GET <url>

{{@response
    const cookieArr = response.headers["Set-Cookie"];
    ....
}}

이러한 형식으로, 요청 앞 뒤에서 요청과 응답 객체에 간섭 및 추출 행위가 가능해진다.

빠른 테스팅을 위해, 아직 httpyac 에서 .js 파일로 이어주는 기능을 사용하지 않고,

기능이 동작하는지 확인하기 위해 먼저 바로 포워딩 해 보았다.

먼저, 나의 프로젝트 디렉토리 현황은 대충 이러하다 :

<root>
  /.httpyac # 직접 만든 디렉토리
    # cookies.json 이라는 파일이 들어갈 예정
  /src
    /users
      requests.http
    /reports
      requests.http

이제 JS Scripting 을 만들어 볼 건데, fs, path 디폴트 라이브러리를 사용한다.

사실 위 디렉토리를 살펴보았다면, requests.http 파일들이 비효율적인 위치에 존재한다는 것을 알 것이다.

이후에 최적화 할 것이라서, 일단 바로 코드를 작성 해 보겠다.

<root>/src/users/request.http

### 유저 로그인
# @name signin
POST http://localhost:3000/auth/signin
content-type: application/json

{
    "email" : "test@gmail.com",
    "password" : "12341234"
}

{{@response
    const fs = require('fs');
    const path = require('path');
    const cookies = response.headers['set-cookie'] || [];
    const jar = cookies.map(c => c.split(';')[0]);

    fs.writeFileSync(
        path.resolve(__dirname + '../../../.httpyac/cookies.json'),
        JSON.stringify(jar, null, 2) // indent 2 번으로 가독성 확보
    );
}}

<root>/.httpyac/cookies.json

[
  "session=eyJ1c2VySWQiOjF9",
  "session.sig=Assbm1VoBVhl6uJ90YDXls2YHPs"
]

<root>/src/reports/requests.http

### POST http://localhost:3000/reports
POST http://localhost:3000/reports
content-type: application/json
{
    "price" : 500000,
    "make" : "toyota",
    "model" : "corolla",
    "year" : 1980,
    "lng" : 0,
    "lat" : 0,
    "mileage" : 100000
}
{{@request
    const fs = require('fs');
    const path = require('path');
    const jar = JSON.parse(
        fs.readFileSync(
            path.resolve('../../.httpyac/cookies.json')
        )
    );
    // 배열을 연결할 때, 중간에 "; " 를 넣어준다.
    request.headers['Cookie'] = jar.join('; ');
}}

물론, 경로 문제를 해결하기 위해, 한 곳에 전부 파일을 넣으면 매우 깔끔해진다.

최적화 하기 전에, 먼저 결과는 2 개 모두 정상작동한다.

다시 키워드를 사용하는게 낫지 않을까?

맞는 말이다. 나도 스크립팅을 작성하면서,

가독성을 해치게 되더라도 그냥 키워드를 사용하는게 더 편하겠다 생각한다.

심지어, 하나의 요청마다 거의 7 줄의 스크립트를 넣어야 하는 상황이다.

문제를 나열 해 보자 :

1. 경로가 너무 일관되지 않는다.
2. 쿠키 정보 주입, 추출 시 마다 스크립트가 7 줄씩 들어간다.
3. 도메인 정보가 주어지지 않고, 그냥 쿠키들만 배열로 json 으로 들어간다.

일단, 1 번은 쉽게 해결 할 수 있다.

기존의 디렉토리 구조는 이러하다 :

<root>
  /.httpyac
    cookies.json
  /src
    /users
      requests.http
    /reports
      requests.http

httpyac 은, 현재 실행되고 있는 로컬 서버에 요청을 날린다.

즉, 딱히 users, reports 디렉토리에 .http 파일이 존재 할 이유는 없다.

디렉토리 구조를 바꾼다 :

<root>
  /.httpyac
    cookies.json
    users-requests.http
    reports-requests.http
  /src
    /users
      기존 파일들..
    /reports
      기존 파일들..

그러나, 경로 문제만 해결되었을 뿐, 반복 스크립팅 문제가 해결되지 않았다.

이를 해결하기 위해 httpyac 에서 어떠한 기능을 발견했는데, 바로 Hooks 기능이었다.

Hooks 기능이란?

우선, httpyac.config.js 파일을 만들면서 사용할 수 있는 다양한 훅이 존재한다.

단순하게 httpyac 명령어를 사용한다고 가정 했을 때,

• package.json
• httpyac.config.js
• .httpyac.js
• .httpyac.json
• .env - 이건 사이트를 참조하길 바랍니다

이러한 파일에 Hook 을 작성 할 수 있다.

httpyac 명령어와 xxx.http 파일을 실행하게 될 시,

현재 디렉토리 --> 부모 디렉토리 --> 위의 파일명이 존재하는 디렉토리

순으로 거쳐가며 정해진 파일을 찾는다.

나의 경우,

<root>
  httpyaac.config.js

  /.httpyac
    users-requests.http
    reports-requests.http
    cookies.json

이러한 파일 계층으로 만들어 두었다.

이는 https://httpyac.github.io/plugins/plugin-api.html 의 hooks 를 참고하면 된다.

그래서, 우리가 .http 파일을 httpyac 으로 실행하는 과정에서 훅은 도대체 왜 필요할까?

아주 간단하게 말하자면,

.http 파일에 어떠한 추가 키워드 없이, 마치 세션이 이어 진 것 처럼 쿠키를 사용 할 수 있다

hooks 에는 기본적으로 Request, Response 객체를 조작 및 추출할 수 있는데,

이는 파일에 직접적으로 작성 할 수 있는 공간을 마련 해 준다.

httpyac.config.js

/**
* @author damhyeong
* @email rhdwhdals8765@gmail.com
*
* 밑의 코드는 서버에서 날아오는 "Set-Cookie" 에 대해 자동으로 설정 해 주는 코드입니다.
*
* VSCode 나 IntelliJ 는 `.http` 파일에 대한 기본적인 실행 환경을 편리하게 만들어 주지만,
*
* 실제로 httpyac 명령어 만으로는 한 번 명령이 수행 된 이후, 모든 세션이 사라지게 됩니다.
*
* 명령이 끝난 이후에도 설정된 Cookies 에 대한 값을 유지하기 위해, File System 을 활용합니다.
*
* (1) Response --> "Set-Cookie" 배열 혹은 단순 문자열 추출
* (2) 추출된 문자열을 분리하여 현재 디렉토리의 "cookies.json" 으로 저장
* (3) Request --> "Cookie" 에 들어가야 할 정보가 필요
* (4) "cookies.json" 으로부터 JSON 파싱
* (5) request.headers["Cookie"] 에 들어가야 할 정보가 필요.
* (6) 이 때, 파일 시스템으로 쿠키 배열, 혹은 문자열 추출
* (7) request.headers["Cookie"] 에 파싱된 쿠키들 적용
* (8) 굳이 불편하게 .http 파일에 스크립팅을 적용 할 필요가 없어진다!
*/

module.exports = {
  // httpyac 명령어 실행 시, 해당 프로세스에서 쿠키를 자동으로 저장하는 Jar 을 잠깐 만든다.
  cookieJarEnabled: true,
  // 커스텀 Hook 제작 - Request 그리고 Response
  configureHooks: function (api) {
    // Response 반응.
    api.hooks.onResponse.addHook("saveCookies", function (response) {
      // 파일 시스템 라이브러리
      const fs = require('fs');
      // 경로 파악 라이브러리 (__dirname 혹은 __filename 사용 가능)
      const path = require('path');
      // 만약에, 서버에서 쿠키 설정 헤더가 없다면, 빈 배열로 할당한다.
      const cookies = response.headers['set-cookie'] || [];

      // 서버가 설정 쿠키를 전달하였다면,
      if (cookies.length !== 0) {
        //
        const jar = cookies.map(c => c.split(';')[0]);
        console.log(jar);
        fs.writeFileSync(
          path.resolve(__dirname + 'cookies.json'),
          JSON.stringify(jar, null, 2)
        );
      }
    });

    // Request 반응.
    api.hooks.onRequest.addHook("insertCookies", function (request) {
      const fs = require('fs');
      const path = require('path');

      const cookieArrStr = fs.readFileSync(
        path.resolve(__dirname + "cookies.json")
      );
      const jar = JSON.parse(cookieArrStr);
      request.headers['Cookie'] = jar.join('; ');
    })
  }
}

위의 코드를 그대로 복사 붙여넣기 해도, 이 글을 활용하기로 결정했다면,

단순 쿠키 저장 및 전달에는 큰 문제가 없다. (같은 디렉토리에 요청, 쿠키 파일이 있다는 가정 하에)

위의 설정 파일의 API 에는 2 가지의 Hook 이 존재한다.

api.hooks.onResponse

• .http 파일 실행 시, 요청 후 응답 객체에서 정보를 추출하여 어떠한 행동이든 할 수 있다.

api.hooks.onRequest

• .http 파일 실행 시, 요청 전 요청 객체에 어떠한 정보를 추가 및 삭제 할 지 결정 할 수 있다.

글이 너무 길어 질 것 같아서, 말하자면, .http 본문에는 어떠한 메타데이터도 넣지 않은 상황이다.

그리고, cookies.json :

[
  "session=eyJ1c2VySWQiOjF9",
  "session.sig=Assbm1VoBVhl6uJ90YDXls2YHPs"
]

요청 시, response 의 Set-Cookie 헤더를 추출하여 정상적으로 파일에 저장하고,

요청 전, request 의 Cookie 헤더에 파일로부터 가져온 쿠키들을 ; 로 연결하여 전달한다.

결과

나는 사용하면서 인식한 3 가지 문제점을 해결했다.

1. 경로의 비 일관성
2. 실행 시, 다른 요청 또한 실행되어 가독성을 해친다.
3. 쿠키 정보를 주입 및 추출하기 위해 스크립트를 7 줄씩 작성해야 한다.

그러나, 도메인 정보는 해결하지 않았는데, 이는 .http 파일이 단순히 내 로컬 파일에서 실행되기 때문이다.

만약에 도메인 정보까지 넣고자 한다면, cookies.json 에 들어갈 내용의 구조가 바뀌며,

onResponse, onRequest 의 내부 로직이 추가된다.

아마, cookies.json 은 이러한 형태를 가지게 될 것이다. (내가 만든다면..)

{
  "localhost" : [
    {
      "path" : "/",
      "name" : "session",
      "value" : "eyJ1c2VySWQiOm51bGx9",
      "date" : -1
    },
    {
      "path" : "/",
      "name" : "session.sig",
      "value" : "tUU3b4KEiPsDoss45BkeyGzl3rQ",
      "date" : -1
    }
  ],
  "<실제 도메인>" : [
    ....
  ]
}

이러한 쿠키 정보를 건네 줄 때는 보통 "domain=xxxx" 도메인 정보가 와야 하는데,

로컬 머신에서는 따로 domain 속성을 보내 주지 않는다.

따라서, domain 이 쿠키 정보에 없을 경우, localhost 로 작성 해 놓는 것이다.

그리고 date 가 -1 을 가지는 이유는, 만료일을 정해 놓지 않았기 때문이다. (무한)

여기엔 숫자 1710223432.. 와 같은 숫자가 들어가며, 이는 1970년 1월 1일부터의 밀리세컨드를 말한다.

httpyac 의 Hook 은 무엇이 있을까?

내가 작성 한 2 개의 Hook 말고도, httpyac 에서 제공하는 다양한 기능이 존재한다.

몇 가지 예를 들자면..

ParseHook

api.hooks.parse.addHook 으로 사용이 가능하며, .http 본문을 읽어 메타데이터를 주입한다.

이 Hook 은 정말 .http 파일을 고도화하여 사용 할 것이라면 추천하지만,

그렇지 않다면 딱히 추천하지 않는다... (regex 사용해서 매칭시킴.)

ReplaceVariableHook

api.hooks.provideVariables.addHook 으로 사용이 가능하며,

작성한 환경 변수 파일 .env.... 을 참조 할 수도 있으며,

.http 파일에 특정 변수를 제공 할 수도 있다.

OnRequestHook

api.hooks.onRequest.addHook 으로 사용이 가능하다.

내가 위에 작성 해 놓은 예제를 보면 알 수 있듯이,

JS 환경의 req 객체를 조작한다고 생각하면 된다.

새로운 헤더를 넣을 수 있으며, 또한 쿠키도 주입 할 수 있다.

OnResponseHook

api.hooks.onResponse.addHook 으로 사용이 가능하다.

이것 또한 위에 쿠키를 추출하기 위한 예제를 만들어 놓았는데,

JS 환경의 res 객체에서 정보를 추출할 수 있다.

이 때, 만약에 나 처럼 쿠키가 아니라,

따로 body 에 액세스 토큰, 리프레쉬 토큰 을 주었을 경우,

이를 포착하여 내가 했던 것 처럼 파일에 저장 할 수도 있다.

더 많은 정보는 https://httpyac.github.io/plugins/plugin-api.html 를 참조하면 된다.

그리고, 여기서 다루지 않는 변수 사용법과 scripting 과 같은 좋은 자료들이 공식 문서에 있다.

맨 밑에 참고 사이트로 "공식 사이트" 를 걸어놓았으니, 보면 굉장히 유용 할 것이다.

이 글을 작성하며 배운 점

사실 나 또한 API 요청을 쉽게 할 수 있는 프로그램이 많다는 것을 안다.

POSTMAN 을 통해 요청을 넣어도 되고, (가장 쉬운 방법)

아니면 E2E 테스팅을 돌려서 확인하는 것이 쉬울 것이다. (Node 의 경우, supertest)

그런데, HttpYac (.http 를 의미) 은 이 중간에 위치한다고 생각한다.

POSTMAN 의 경우, CI/CD 과정의 복잡성이 늘어나고, 프로그램을 더 켜야 한다는 문제점이 있다.

E2E 테스팅의 경우, 요청 검증을 위해 매번 모듈을 "테스트가 직접 생성" 하여 느리다는 문제가 있다.

하지만 .http 파일을 사용한다면, 현재 실행중인 Dev 서버에 곧바로 요청을 날릴 수 있다.

그러나, HttpYac 프로그램 자체의 한계성도 느낄 수 있었다.

IntelliJ 나 VSCode 와는 달리, CLI 로서 세션을 유지하기 위해,

파일 시스템을 다루며 직접 정보를 작성해야 하고,

Request 혹은 Response 객체에 직접 세션 정보들을 넣어주어야 한다는 것이다.

IntelliJ 에서는 요청과 응답 내용에 대한 내용을

.idea 폴더에 직접 저장하여 사용한다.

이 때문에 딱히 Hook 을 작성하지 않고도 세션을 유지하는 것 처럼 요청을 보낼 수 있다.

만약에 E2E 테스팅 도구들이 적고 기능이 별반 없었으면

CI/CD 과정에서 굉장히 유용하게 사용했을 것 같은데,

Node.js 환경에서는 Jest 와 Supertest 라는 훌륭한 E2E 테스팅 라이브러리가 있어

로컬 머신에서 간단히 테스팅 하는 용도로 사용 할 것 같다.

---

참고 사이트

HttpYac 공식 사이트

https://httpyac.github.io/

IntelliJ IDEA 의 요청 세션 저장 방식을 참고함

<IntelliJ 프로젝트 루트>
  /.idea
    /httpRequests
      <연-월-일-시간>.<응답코드>.json
      ...
      http-client.cookies # 여기에 쿠키를 저장 (텍스트 형식으로)
      ...