JUnit - @ParameterizedTest, @ValueSource, @CsvSource, @MethodSource 어노테이션

• 안녕하세요~ 이전에 운영하던 블로그 및 GitHub, 공부 내용을 정리하는 Study-GitHub 가 있습니다!

• 네이버 블로그

• GitHub

• Study-GitHub

• 🐔

---

📎 JUnit5 - @ParameterizedTest, @ValueSource, @CsvSource, @MethodSource

 

안녕하세요! 이번 시간에 정리할 내용은 JUnit에서 파라미터의 테스트와 관련된 다양한 테스트 방법입니다.

 

이번에 넥스트스텝에서 진행하는 자바 플레이그라운드 과정을 들으면서 테스트 코드를 작성하고 있는데요,

이와 관련해 파라미터의 중복 값에 대한 테스트 코드를 제거하거나, 입력 값에 따라 결과 값이 다른 경우도 테스트가 가능하도록 구현하는 과정에서 위의 어노테이션을 사용하게 되었는데요, 간략하게 정리해보도록 하겠습니다.

 

 

먼저 해당 라이브러리를 사용하기 위해 의존성을 추가합니다.

 

Maven - pom.xml

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-params</artifactId>
    <version>5.7.0</version>
    <scope>test</scope>
</dependency>

 

 

Gradle - build.gradle

testCompile("org.junit.jupiter:junit-jupiter-params:5.7.0")

 

 

* 참고로 현재 제가 사용하고 있는 Gradle의 디펜던시는 다음과 같습니다.

dependencies {
    testImplementation "org.junit.jupiter:junit-jupiter:5.7.2"
    testImplementation "org.assertj:assertj-core:3.19.0"
}

 

 

 

@ParameterizedTest, @ValueSource

그럼 @ParameterizedTest 어노테이션을 언제 사용하는지 살펴보겠습니다.

    private Set<Integer> numbers;

    @BeforeEach
    void setUp() {
        numbers = new HashSet<>();
        numbers.add(1);
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
    }

    @Test
    void set_contains_test() {
        assertThat(numbers.contains(1)).isTrue();
        assertThat(numbers.contains(2)).isTrue();
        assertThat(numbers.contains(3)).isTrue();
        ...
    }

위 코드처럼 Set 컬렉션에 여러 값이 확인되어있는지 확인하려면 코드를 여러번 작성하는 중복 코드가 발생하게 됩니다.

 

따라서, 위와 같이 중복 코드가 발생했을 때 @ParameterizedTest 어노테이션을 사용할 수 있는데요,

위 코드를 다음과 같이 나타낼 수 있습니다.

    @ParameterizedTest
    @ValueSource(ints = {1, 2, 3})
    void set_contains_test(int element) {
        assertThat(numbers.contains(element)).isTrue();
    }

테스트 결과를 살펴보면 @ValueSource 어노테이션에 선언된 1, 2, 3 의 값을 테스트하는 것을 볼 수 있습니다.

 

@ValueSource는 리터럴 값의 배열에 대한 접근을 제공하는 어노테이션 입니다.

자세한 내용은 공식문서 에서 확인해주세요 :)

 

@ValueSource의 다른 예제로 다음과 같이 사용할 수 있습니다.

public class Numbers {
    public static boolean isOdd(int number) {
        return number % 2 != 0;
    }
}


@ParameterizedTest
@ValueSource(ints = {1, 5, 9, -7, 15, 21}) // six numbers
void isOdd_ShouldReturnTrueForOddNumbers(int number) {
    assertThat(Numbers.isOdd(number)).isTrue();
}

 

 

@ValueSource의 코드는 다음과 같습니다.

/*
 * Copyright 2015-2020 the original author or authors.
 *
 * All rights reserved. This program and the accompanying materials are
 * made available under the terms of the Eclipse Public License v2.0 which
 * accompanies this distribution and is available at
 *
 * https://www.eclipse.org/legal/epl-v20.html
 */

package org.junit.jupiter.params.provider;

import static org.apiguardian.api.API.Status.STABLE;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import org.apiguardian.api.API;

/**
 * {@code @ValueSource} is an {@link ArgumentsSource} which provides access to
 * an array of literal values.
 *
 * <p>Supported types include {@link #shorts}, {@link #bytes}, {@link #ints},
 * {@link #longs}, {@link #floats}, {@link #doubles}, {@link #chars},
 * {@link #booleans}, {@link #strings}, and {@link #classes}. Note, however,
 * that only one of the supported types may be specified per
 * {@code @ValueSource} declaration.
 *
 * <p>The supplied literal values will be provided as arguments to the
 * annotated {@code @ParameterizedTest} method.
 *
 * @since 5.0
 * @see org.junit.jupiter.params.provider.ArgumentsSource
 * @see org.junit.jupiter.params.ParameterizedTest
 */
@Target({ ElementType.ANNOTATION_TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@API(status = STABLE, since = "5.7")
@ArgumentsSource(ValueArgumentsProvider.class)
public @interface ValueSource {

	/**
	 * The {@code short} values to use as sources of arguments; must not be empty.
	 *
	 * @since 5.1
	 */
	short[] shorts() default {};

	/**
	 * The {@code byte} values to use as sources of arguments; must not be empty.
	 *
	 * @since 5.1
	 */
	byte[] bytes() default {};

	/**
	 * The {@code int} values to use as sources of arguments; must not be empty.
	 */
	int[] ints() default {};

	/**
	 * The {@code long} values to use as sources of arguments; must not be empty.
	 */
	long[] longs() default {};

	/**
	 * The {@code float} values to use as sources of arguments; must not be empty.
	 *
	 * @since 5.1
	 */
	float[] floats() default {};

	/**
	 * The {@code double} values to use as sources of arguments; must not be empty.
	 */
	double[] doubles() default {};

	/**
	 * The {@code char} values to use as sources of arguments; must not be empty.
	 *
	 * @since 5.1
	 */
	char[] chars() default {};

	/**
	 * The {@code boolean} values to use as sources of arguments; must not be empty.
	 *
	 * @since 5.5
	 */
	boolean[] booleans() default {};

	/**
	 * The {@link String} values to use as sources of arguments; must not be empty.
	 */
	String[] strings() default {};

	/**
	 * The {@link Class} values to use as sources of arguments; must not be empty.
	 *
	 * @since 5.1
	 */
	Class<?>[] classes() default {};

}

 

 

 

@ParameterizedTest, @CsvSource

위의 @ValueSource 어노테이션을 사용한 set 테스트에서 모든 조건은 항상 true를 리턴하도록 되어있었는데요,

만약 위와같은 상황이 아닌, 입력값에 따라 결과값이 다른 경우를 테스트 하려면 @CsvSource를 사용해 테스트를 할 수 있습니다.

 

CSV(Comma Separated Values)는 이름을 통해 알 수 있듯이, 콤마(default)를 기준으로 CSV를 구분해서 읽습니다.

  ※ 구분자는 커스터마이징이 가능합니다.

@CsvSource Annotation

 

 

테스트 코드는 다음과 같습니다.

    @DisplayName("true, false 값을 같이 리턴한다")
    @ParameterizedTest
    @CsvSource(value = {"1:true", "2:true", "3:true", "4:false", "5:false"}, delimiter = ':')
    void set_contains_true_false(int element, boolean expected) {
        assertThat(numbers.contains(element)).isEqualTo(expected);
    }

@CsvSource 어노테이션에 delimiter 을 직접 정의함으로써 구분자를 지정할 수 있습니다.

 

위 코드에서 set은 1, 2, 3 을 가지고 있기 때문에 true를, 4와 5는 false를 반환합니다.

 

 

 

 

@ParameterizedTest, @MethodSource

@MethodSource 어노테이션은 다음과 같은 상황에서 사용을 했습니다.

 

숫자야구게임에 대해 짝프로그래밍을 하던 도중, 스트라이크 & 볼에 대한 테스트 코드를 작성을 해야했는데요, 

두 테스트 모두 플레이어, 컴퓨터의 숫자를 가지고 있어야 합니다.

 

따라서 파라미터를 테스트를 하는데 따로 구현을 하게 되면 중복 코드가 발생해서 @MethodSource 어노테이션을 통해 여러 값들에 대해 동일하게 사용할 수 있도록 작성을 했습니다.

 

 

@MethodSource 의 코드는 다음과 같습니다.

@Target({ ElementType.ANNOTATION_TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@API(status = STABLE, since = "5.7")
@ArgumentsSource(MethodArgumentsProvider.class)
public @interface MethodSource {

	/**
	 * The names of factory methods within the test class or in external classes
	 * to use as sources for arguments.
	 *
	 * <p>Factory methods in external classes must be referenced by <em>fully
	 * qualified method name</em> &mdash; for example,
	 * {@code com.example.StringsProviders#blankStrings}.
	 *
	 * <p>If no factory method names are declared, a method within the test class
	 * that has the same name as the test method will be used as the factory
	 * method by default.
	 *
	 * <p>For further information, see the {@linkplain MethodSource class-level Javadoc}.
	 */
	String[] value() default "";

}

 

 

 

테스트에 사용한 실제 코드는 다음과 같습니다.

import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;

...

    @DisplayName("스트라이크 테스트")
    @ParameterizedTest
    @MethodSource("generateData")
    public void test1(List<Integer> playerLists, List<Integer> computerLists, int index) {
        PlayResult playResult = new PlayResult();
        int strikeCount = playResult.countStrike(playerLists, computerLists);

        int[] result = {1, 0};
        assertThat(strikeCount).isEqualTo(result[index]);
    }

    @DisplayName("볼 테스트")
    @ParameterizedTest
    @MethodSource("generateData")
    void test_ball(List<Integer> playerLists, List<Integer> computerLists, int index) {
        PlayResult playResult = new PlayResult();
        int ballCount = playResult.countBall(playerLists, computerLists);

        int[] result = {2, 0};
        assertThat(ballCount).isEqualTo(result[index]);
    }

    static Stream<Arguments> generateData() {
        return Stream.of(
                Arguments.of(Arrays.asList(1, 2, 3), Arrays.asList(1, 3, 2), 0),
                Arguments.of(Arrays.asList(1, 2, 3), Arrays.asList(4, 5, 6), 1)
        );
    }

 

generateData() 메서드를 통해 테스트할 파라미터를 Stream<Arguments>로 생성합니다.

그 후 @MethodSource 어노테이션의 괄호에 해당 메서드 이름을 작성하면 파라미터 테스트가 가능합니다.

@MethodSource 어노테이션이 작동하는 구조를 대략적으로 나타내면 아래와 같습니다.

 

 

이상으로 JUnit의 파라미터 테스트와 관련된 @ParameterizedTest, @ValueSource, @CsvSource, @MethodSource 어노테이션에 대해 간략히 살펴보았습니다.

 

혹시 위 어노테이션 말고도 AssertJ에 대해 다양한 테스트 코드를 살펴보시려면 아래 링크를 참조해주세요 :)

https://www.baeldung.com/introduction-to-assertj

 

 

배우면 배울수록 공부할게 더 많아지는 것 같습니다 😭

위와 같은 파라미터 테스트는 다양한 파라미터를 테스트해야 하는 경우, 중복되는 코드를 줄일 수 있다는 점에서 유용한 방법인 것 같습니다

 

 

 

 

 

References

https://www.baeldung.com/parameterized-tests-junit-5