[Test] 인수테스트 가독성 증가시키기

 

 

 

🧐 인수 테스트

시스템의 인수를 위해 기능적/비기능적 요구사항을 사용자가 직접 테스트하여 개발이 완료되었음을 증명하는 테스트

인수 테스트는 위와 같이 시스템의 인수를 위해 작성하는 테스트입니다.

즉 인수테스의 목적은 사용자들이 원하는 시나리오대로 기능이 잘 동작하는지를 검증하는 것이라 할 수 있습니다.

 

이번 글에서는 인수 테스트를 작성할 때, 가독성을 높여 테스트를 작성하는 방법에 대해서 알아보도록 하겠습니다.

 

 

 

 

🧐 RestAssured 코드 숨기기

인수테스트는 그 목적에 따라 개발자가 아닌 사람들이 보더라도 쉽게 이해할 수 있도록 테스트를 작성하는 것이 중요하다고 생각합니다.

그래서 저는 개발과 관련된 코드를 최대한 감추어 코드를 작성하는 데 초점을 두어 테스트를 작성하였습니다.

예시 코드와 함께 살펴보겠습니다.

 

예시 코드는 노선에 최초로 역을 등록하는 과정에 대한 테스트입니다.

@Test
void 노선에_최초로_역을_등록한다() {
    // given
    given().contentType(JSON)
           .body(new StationCreateRequest("출발역"))
           .when()
           .post("/stations")
           .then()
           .extract();

    given().contentType(JSON)
           .body(new StationCreateRequest("종착역"))
           .when()
           .post("/stations")
           .then()
           .extract();

    given().contentType(JSON)
           .body(new LineCreateRequest("1호선", 0))
           .when()
           .post("/lines")
           .then()
           .extract();

    // when
    ExtractableResponse<Response> response = given().log().all()
           .contentType(JSON)
           .body(new AddStationToLineRequest("1호선", "출발역", "종착역", 10))
           .when()
           .post("/lines/stations")
           .then()
           .log().all()
           .extract();

    // then
    assertStatusCode(response, 200);
    ExtractableResponse<Response> queryAllLineResponse = given().when()
           .get("/lines")
           .then()
           .extract();
       
    List<LineQueryResponse> list = queryAllLineResponse.jsonPath()
           .getList("", LineQueryResponse.class);
    assertThat(list).hasSize(1);

    LineQueryResponse line = list.get(0);
    assertThat(line.getLineName()).isEqualTo("1호선");

    SectionQueryResponse section = line.getStationQueryResponseList().get(0);
    assertThat(section.getUpStationName()).isEqualTo("출발역");
    assertThat(section.getDownStationName()).isEqualTo("종착역");
    assertThat(section.getDistance()).isEqualTo(10);
}

 

 

 

기존 코드가 위와 같을 때, RestAssured와 관련된 코드를 숨기면 아래와 같아집니다.

@Test
void 노선에_최초로_역을_등록한다() {
    // given
    createStationRequest("출발역");
    createStationRequest("종착역");
    createLineRequest("1호선", 0);

    // when
    ExtractableResponse<Response> response = addStationToLineRequest("1호선", "출발역", "종착역", 10);

    // then
    assertStatusCode(response, 200);
    ExtractableResponse<Response> queryAllLineResponse = queryAllLineRequest();

    List<LineQueryResponse> list = queryAllLineResponse.jsonPath()
              .getList("", LineQueryResponse.class);
    assertThat(list).hasSize(1);
    LineQueryResponse line = list.get(0);
    assertThat(line.getLineName()).isEqualTo("1호선");
    SectionQueryResponse section = line.getStationQueryResponseList().get(0);
    assertThat(section.getUpStationName()).isEqualTo("출발역");
    assertThat(section.getDownStationName()).isEqualTo("종착역");
    assertThat(section.getDistance()).isEqualTo(10);
}

 

given, when 부분은 가독성이 개선되었지만, then의 검증부는 아직 가독성이 좋다고 느껴지지 않습니다.

이를 어떻게 개선할 수 있을까요?

 

 

📕 usingRecursiveComparision() 사용하기

현재 List의 내부 값을들 검증하기 위해, 하나하나 값들을 꺼내어 이를 비교하는 식으로 검증을 진행하는데요,

이로 인해 테스트코드의 가독성이 많이 저하되었습니다.

이를 usingRecursiveComparision()을 통해 개선하면 다음과 같습니다.

 

 

 

 

기존 코드

ExtractableResponse<Response> queryAllLineResponse = queryAllLineRequest();
List<LineQueryResponse> list = queryAllLineResponse.jsonPath()
            .getList("", LineQueryResponse.class);
assertThat(list).hasSize(1);

LineQueryResponse line = list.get(0);
assertThat(line.getLineName()).isEqualTo("1호선");

SectionQueryResponse section = line.getStationQueryResponseList().get(0);
assertThat(section.getUpStationName()).isEqualTo("출발역");
assertThat(section.getDownStationName()).isEqualTo("종착역");
assertThat(section.getDistance()).isEqualTo(10);

 

개선

 List<LineQueryResponse> expected = List.of(
         new LineQueryResponse("1호선", 0, List.of(
                  new SectionQueryResponse("출발역", "종착역", 10)
         )));

 ExtractableResponse<Response> queryAllLineResponse = queryAllLineRequest();
 List<LineQueryResponse> actual = queryAllLineResponse.jsonPath()
                .getList("", LineQueryResponse.class);
 assertThat(actual).usingRecursiveComparison()
         .isEqualTo(expected);

 

usingRecursiveComparision() 를 간단하게 설명하면, 내부 필드의 값들을 비교해주는 메서드입니다.

이는 equals()가 정의되지 않은 객체들을 비교할 때 유용하게 사용할 수 있습니다.

 

또한 생성시간과 같이, 정확하게 비교할 수 없는 값들에 대해서는 null을 넣으면 무시할 수 있도록 ignoringExpectedNullFields() 와 같은 추가 기능들도 제공하니 참고하시면 좋을 것 같습니다.

 

 

 

 

 

 

📙 TypeRef 통한 List 변환 개선

List<LineQueryResponse> actual = queryAllLineResponse.jsonPath()
            .getList("", LineQueryResponse.class);

 

위 코드도 한번 더 개선이 가능합니다.

바로 ExtractableResponse의 as()와, TypeRef 클래스를 사용하는 것입니다.

 

ExtractableResponse의 as() 는 응답 메서드 바디에 들어있는 json 값을 특정 객체로 바꾸어주는 역할을 수행하지만, List<String>과 같이 제네릭 타입의 경우 런타임 시에 타입이 소거되므로 안전하게 변환하기 어렵다는 단점이 있습니다.

 

이를 TypeRef를 통해 해결할 수 있는데요, 더 자세한 원리가 궁금하다면 슈퍼 타입 토큰에 대해서 찾아보시면 좋을 것 같습니다.

사용법은 다음과 같습니다.

List<LineQueryResponse> actual = queryAllLineResponse.as(new TypeRef<>(){});

 

 

 

 

이들을 적용하여 개선된 코드는 다음과 같습니다.

@Test
void 노선에_최초로_역을_등록한다() {
    // given
    createStationRequest("출발역");
    createStationRequest("종착역");
    createLineRequest("1호선", 0);

    // when
    ExtractableResponse<Response> response = addStationToLineRequest("1호선", "출발역", "종착역", 10);

    // then
    assertStatusCode(response, 200);
    List<LineQueryResponse> expected = List.of(
        new LineQueryResponse("1호선", 0, List.of(
            new SectionQueryResponse("출발역", "종착역", 10)
        )));

    ExtractableResponse<Response> allLineQueryResponse = queryAllLineRequest();
    List<LineQueryResponse> actual = allLineQueryResponse.as(new TypeRef<>(){});
    assertThat(actual).usingRecursiveComparison()
                .ignoringExpectedNullFields()
                .isEqualTo(expected);
}

 

 

 

📒 검증부 코드도 메서드 추출하기

코드의 검증부도 메서드로 추출하여 가독성을 증가시킬 수 있습니다.

현재 코드는 다음과 같습니다.

List<LineQueryResponse> expected = List.of(
        new LineQueryResponse("1호선", 0, List.of(
            new SectionQueryResponse("출발역", "종착역", 10)
        )));

ExtractableResponse<Response> allLineQueryResponse = queryAllLineRequest();
List<LineQueryResponse> actual = allLineQueryResponse.as(new TypeRef<>(){});
assertThat(actual).usingRecursiveComparison()
        .ignoringExpectedNullFields()
        .isEqualTo(expected);

 

 

이를 다음과 같이 메서드로 추출하여 가독성을 개선할 수 있습니다.

List<LineQueryResponse> expected = lineQueryResponses(
        lineQueryResponse(
                "1호선", 0,
                sectionQueryResponse("출발역", "종착역", 10)
        )
 );

ExtractableResponse<Response> allLineQueryResponse = queryAllLineRequest();
assertAllLineQueryResponse(allLineQueryResponse, expected);

 

 

 

전체 코드는 다음과 같습니다.

@Test
void 노선에_최초로_역을_등록한다() {
    // given
    createStationRequest("출발역");
    createStationRequest("종착역");
    createLineRequest("1호선", 0);

    // when
    ExtractableResponse<Response> response = addStationToLineRequest("1호선", "출발역", "종착역", 10);

    // then
    assertStatusCode(response, 200);
    List<LineQueryResponse> expected = lineQueryResponses(
                lineQueryResponse(
                    "1호선", 0,
                    sectionQueryResponse("출발역", "종착역", 10)
                )
        );

    ExtractableResponse<Response> allLineQueryResponse = queryAllLineRequest();
    assertAllLineQueryResponse(allLineQueryResponse, expected);
}

private ExtractableResponse<Response> createStationRequest(String name) {
    return given().contentType(JSON)
                .body(new StationCreateRequest(name))
                .when()
                .post("/stations")
                .then()
                .extract();
}

private ExtractableResponse<Response> createLineRequest(String name, int surcharge) {
    return given().contentType(JSON)
                .body(new LineCreateRequest(name, surcharge))
                .when()
                .post("/lines")
                .then()
                .extract();
}

private ExtractableResponse<Response> addStationToLineRequest(
        String lineName,
        String upStationName,
        String downStationName,
        int distance
) {
    return given().log().all()
                .contentType(JSON)
                .body(new AddStationToLineRequest(lineName, upStationName, downStationName, distance))
                .when()
                .post("/lines/stations")
                .then()
                .log().all()
                .extract();
}

private void assertStatusCode(ExtractableResponse<Response> response, int code) {
    assertThat(response.statusCode()).isEqualTo(code);
}

private List<LineQueryResponse> lineQueryResponses(
    LineQueryResponse... lineQueryResponses
) {
    return Arrays.asList(lineQueryResponses);
}

private LineQueryResponse lineQueryResponse(
    String lineName,
    int surcharge,
    SectionQueryResponse... sectionQueryResponses
) {
    return new LineQueryResponse(lineName, surcharge,
            Arrays.asList(sectionQueryResponses)
        );
}

private SectionQueryResponse sectionQueryResponse(
        String upStationName,
        String downStationName,
        int distance
) {
    return new SectionQueryResponse(upStationName, downStationName, distance);
}

private ExtractableResponse<Response> queryAllLineRequest() {
    return given().when()
                .get("/lines")
                .then()
                .extract();
}

private void assertAllLineQueryResponse(
        ExtractableResponse<Response> allLineQueryResponse,
        List<LineQueryResponse> expected
) {
    List<LineQueryResponse> actual = allLineQueryResponse.as(new TypeRef<>() {});
    assertThat(actual).usingRecursiveComparison()
                .ignoringExpectedNullFields()
                .isEqualTo(expected);
}

 

 

 

 

 

 

 

 

🧐 한글을 통해 인수테스트 가독성 높이기

인수테스트의 목적에 따라, 개발자가 아닌 사람들이 보더라도 쉽게 이해할 수 있도록 테스트를 작성하는 것이 중요하다고 생각합니다.

이를 위해 영어 대신 한국어 메서드를 통해 테스트 코드의 가독성을 증가시킬 수 있는데요, 한번 적용하면서 확인해 보겠습니다.

기존 코드는 다음과 같았습니다.

@Test
void 노선에_최초로_역을_등록한다() {
    // given
    createStationRequest("출발역");
    createStationRequest("종착역");
    createLineRequest("1호선", 0);

    // when
    ExtractableResponse<Response> response = addStationToLineRequest("1호선", "출발역", "종착역", 10);

    // then
    assertStatusCode(response, 200);

    List<LineQueryResponse> expected = lineQueryResponses(
                lineQueryResponse(
                    "1호선", 0,
                    sectionQueryResponse("출발역", "종착역", 10)
                )
    );
    ExtractableResponse<Response> allLineQueryResponse = queryAllLineRequest();
    assertAllLineQueryResponse(allLineQueryResponse, expected);
}

 

 

 

이제 각 메서드들을 한글로 바꾸어 보겠습니다.

@Test
void 노선에_최초로_역을_등록한다() {
    // given
    역_생성_요청("출발역");
    역_생성_요청("종착역");
    노선_생성_요청("1호선", 0);

    // when
    ExtractableResponse<Response> 역_추가_응답 = 노선에_역_추가_요청("1호선", "출발역", "종착역", 10);

    // then
    상태_코드_검증(역_추가_응답, 200);
    List<LineQueryResponse> 예상_결과 = 전체_노선_조회_결과(
                단일_노선_정보(
                        "1호선", 0,
                        구간_정보("출발역", "종착역", 10)
                )
    );
    ExtractableResponse<Response> 전체_노선_조회_응답 = 전체_노선_조회_요청();
    전체_노선_조회_결과_검증(전체_노선_조회_응답, 예상_결과);
}

 

 

제가 영어를 못해서 그런지, 영어에 비해 읽기 쉬워진 느낌이 있습니다.

 

 

📕 var 사용하기

코드를 살펴보면 ExtractableResponse<Response> 라는 부분은 별로 중요하지 않다는 것을 알 수 있습니다.

(List<LineQueryResponse> 역시 인수 테스트의 관점에서는 그닥 중요하지 않다고 생각할 수 있습니다)

 

이를 var 을 통해 감추면 다음과 같아집니다.

@Test
void 노선에_최초로_역을_등록한다() {
    // given
    역_생성_요청("출발역");
    역_생성_요청("종착역");
    노선_생성_요청("1호선", 0);
    
    // when
    var 역_추가_응답 = 노선에_역_추가_요청("1호선", "출발역", "종착역", 10);

    // then
    상태_코드_검증(역_추가_응답, 200);
    var 예상_결과 = 전체_노선_조회_결과(
            단일_노선_정보(
                "1호선", 0,
                구간_정보("출발역", "종착역", 10)
            )
    );

    var 전체_노선_조회_응답 = 전체_노선_조회_요청();
    전체_노선_조회_결과_검증(전체_노선_조회_응답, 예상_결과);
}

 

 

📙 파라미터 한글로 바꾸기

메서드의 파라미터 역시 한글로 바꾸면 가독성이 훨씬 증가합니다.

예를 들어 다음과 같은 코드에서

파라미터를 한글로 바꾸면 다음과 같습니다.

 

 

 

 

 

🧐 여러 요청들을 추출하여 재사용하기

역 생성 요청과, 노선 생성 요청과 같은 요청들은 여러 인수 테스트에서 사용될 수 있습니다.

이들을 각각의 인수 테스트에서 계속 만들어서 사용하는 것은 비효율적이므로, 이들을 추출하여 여러 인수 테스트에서 재사용할 수 있도록 만들어 주는 것이 좋습니다.

 

예를 들어 역_생성_요청() 의 경우 StationSteps라는 클래스로,

노선_생성_요청()의 경우 LineSteps라는 클래스로 추출할 수 있습니다.

 

몇가지만 예시로 살펴보면 다음과 같습니다.

public class StationSteps {

    public static ExtractableResponse<Response> 역_생성_요청(final String 역_이름) {
        return given().contentType(JSON)
                .body(new StationCreateRequest(name))
                .when()
                .post("/stations")
                .then()
                .extract();;
    }
}

public class LineSteps {

    public static ExtractableResponse<Response> 노선_생성_요청(
        String 노선_이름, 
        int 추가요금
    ) {
        return given().contentType(JSON)
                .body(new LineCreateRequest(노선_이름, 추가요금))
                .when()
                .post("/lines")
                .then()
                .extract();
    }

    public static List<LineQueryResponse> 전체_노선_조회_결과(
        LineQueryResponse... 노선_정보들
    ) {
        return Arrays.asList(노선_정보들);
    }
}

 

이들을 통해, 이후 추가로 작성되는 기능들에 대해서 인수 테스트를 작성할 때, 기존 요청들을 재사용하여 원하는 상황을 만들고 테스트할 수 있습니다.