JUnit에서 함수형 인터페이스와의 통합은 어떻게 하나요?

Q1: JUnit에서 함수형 인터페이스를 어떻게 사용할 수 있나요?
A1: JUnit은 자바 8 이상에서 지원하는 람다 표현식과 함수형 인터페이스를 자연스럽게 지원합니다. 테스트 메서드 내에서 `Runnable`, `Supplier`, `Consumer` 같은 함수형 인터페이스를 사용하여 코드의 가독성과 재사용성을 높일 수 있습니다.

---

Q2: 함수형 인터페이스를 사용해 예외 발생 테스트를 작성할 수 있나요?
A2: 네, JUnit 5에서는 `assertThrows` 메서드가 함수형 인터페이스인 `Executable`을 인자로 받습니다. 이를 이용해 람다로 예외 발생 테스트를 직관적으로 작성할 수 있습니다.

```java
@Test
void testException() {
assertThrows(IllegalArgumentException.class, () -> {
// 예외를 발생시키는 코드
throw new IllegalArgumentException("Invalid argument");
});
}
```

이처럼 람다(함수형 인터페이스)를 입력으로 사용하는 방식이 가능합니다.

---

Q3: 함수형 인터페이스를 활용해 반복되는 테스트 코드를 줄일 수 있나요?
A3: 예, 반복되는 로직을 함수형 인터페이스에 담아 재사용하는 방법이 있습니다. 예를 들어, 공통 검증 로직을 `Consumer` 나 `Function`로 정의하고 여러 테스트에서 호출할 수 있습니다.

```java
Consumer validateNonEmpty = str -> assertFalse(str.isEmpty());

@Test
void testString1() {
validateNonEmpty.accept("JUnit");
}

@Test
void testString2() {
validateNonEmpty.accept("Lambda");
}
```

---

Q4: JUnit 4와 5 모두에서 함수형 인터페이스를 쓸 수 있나요?
A4: JUnit 5는 자바 8 이상을 요구하므로 함수형 인터페이스와 람다를 자연스럽게 지원합니다. JUnit 4 역시 자바 8 이상에서 람다를 사용할 수 있으나, JUnit 5의 `assertThrows` 같은 메서드는 없기 때문에 예외 테스트는 다른 방식으로 작성해야 할 수 있습니다.

---

Q5: 커스텀 어설션에 함수형 인터페이스를 활용할 수 있나요?
A5: 네, 함수형 인터페이스를 활용하면 커스텀 어설션 메서드를 만들 때 코드를 간결하게 유지할 수 있습니다. 예를 들어 `Supplier`, `Predicate` 등을 인자로 받아 특정 조건을 검증하는 유틸리티 메서드를 만들 수 있습니다.

```java
public static void assertCondition(T value, Predicate condition) {
assertTrue(condition.test(value), "Condition failed for value: " + value);
}

@Test
void testCustomAssertion() {
assertCondition(5, x -> x > 0);
}
```

---

Q6: 함수형 인터페이스를 이용해 동적 테스트(Dynamic Tests)를 만들 수 있나요?
A6: JUnit 5의 `@TestFactory`와 함께 함수형 인터페이스(예: `Executable`)를 활용하여 동적 테스트를 생성할 수 있습니다. 람다를 이용해 각 테스트 케이스를 쉽게 정의할 수 있어서 테스트 생성과 유지보수가 편리해집니다.

```java
@TestFactory
Collection dynamicTests() {
return Arrays.asList(
DynamicTest.dynamicTest("Test 1", () -> assertTrue(true)),
DynamicTest.dynamicTest("Test 2", () -> assertEquals(2, 1 + 1))
);
}
```

---

요약
- JUnit 5는 함수형 인터페이스와 람다를 기본적으로 지원하여 `assertThrows`, `@TestFactory` 등과 함께 사용하기 편리합니다.
- 공통 로직을 함수형 인터페이스로 추출해 재사용하고, 커스텀 어설션에도 활용할 수 있습니다.
- JUnit 4도 자바 8 이상 환경에서는 람다 사용이 가능하지만, 함수형 인터페이스를 활용한 일부 기능은 JUnit 5에서 더 완벽히 지원됩니다.

JUnit에서 @Timeout 애너테이션을 사용하는 방법은?

JUnit의 테스트 케이스 수명주기란 무엇인가요?

JUnit에서 함수형 인터페이스와의 통합은 주로 람다 표현식이나 메서드 참조를 사용해 테스트 코드의 가독성과 재사용성을 향상시키는 데 중점을 둡니다.

JUnit 5와 같은 최신 버전은 자바 8 이상의 기능을 활용하므로 함수형 프로그래밍 스타일과 잘 맞습니다.

1. 함수형 인터페이스와 람다 표현식의 기본 이해 함수형 인터페이스는 딱 하나의 추상 메서드만 가지는 인터페이스로, 자바에서 람다 표현식으로 쉽게 구현할 수 있습니다.

예를 들어 `Predicate`, `Function`, `Supplier`, `Consumer` 등이 있습니다.

이러한 인터페이스를 테스트 코드 안에서 활용하면 테스트 대상 로직을 매개변수화하거나 커스터마이즈할 때 유용합니다.



2. JUnit에서 함수형 인터페이스 활용 예시: 테스트 데이터 커스터마이징 JUnit 테스트 메서드 내에서 람다를 인자로 받아 조건에 맞는 로직을 수행하거나, 재사용 가능한 검증 로직을 함수형 인터페이스로 정의할 수 있습니다.

예시: ```java import static org.junit.jupiter.api.Assertions.*; import org.junit.jupiter.api.Test; import java.util.function.Predicate; class MyServiceTest { // 테스트 대상 메서드 boolean isValidString(String s, Predicate condition) { return condition.test(s); } @Test void testIsValidString() { Predicate isNotEmpty = str -> !str.isEmpty(); assertTrue(isValidString("hello", isNotEmpty)); assertFalse(isValidString("", isNotEmpty)); } } ``` 위 예제에서 함수형 인터페이스 `Predicate`을 활용해 조건을 테스트 로직과 분리했습니다.



3. assertThrows와 함수형 인터페이스 JUnit 5의 `assertThrows` 메서드는 `Executable`이라는 함수형 인터페이스(람다)를 인자로 받습니다.

그래서 예외 발생 테스트 시 람다를 바로 전달할 수 있어 매우 직관적입니다.

```java import static org.junit.jupiter.api.Assertions.*; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.function.Executable; class CalculatorTest { @Test void testDivideByZero() { Calculator calc = new Calculator(); // Executable은 함수형 인터페이스, 람다를 사용할 수 있음 Executable divideByZero = () -> calc.divide(10, 0); assertThrows(ArithmeticException.class, divideByZero); } } ```

4. 사용자 정의 함수형 인터페이스를 활용한 테스트 구조 개선 때로는 표준 함수형 인터페이스로 부족할 수 있으니, 필요한 형태대로 함수형 인터페이스를 직접 선언하고 테스트에 적용할 수 있습니다.

예를 들어 특정 예외 처리나 복잡한 입력값 생성용으로 사용할 수 있습니다.

```java @FunctionalInterface interface ThrowingSupplier { T get() throws Exception; } class SomeTest { void runTest(ThrowingSupplier supplier) throws Exception { String value = supplier.get(); assertNotNull(value); } @Test void testSupplier() throws Exception { runTest(() -> "Hello from supplier"); } } ```

5. Parameterized Tests에서 함수형 인터페이스와 람다 활용 JUnit 5의 파라미터화 테스트 기능과 결합하면, 각 테스트 케이스에 함수형 인터페이스나 람다를 직접 매개변수로 전달해 테스트 로직을 더욱 유연하게 만들 수 있습니다.

```java import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.MethodSource; import java.util.function.Function; import java.util.stream.Stream; class StringTest { static Stream> conditions() { return Stream.of( s -> s.length() > 3, s -> s.startsWith("J"), String::isEmpty ); } @ParameterizedTest @MethodSource("conditions") void testWithFunctions(Function condition) { assertNotNull(condition); // 입력에 따라 조건 테스트 assertTrue(condition.apply("JUnit")); } } ``` 정리 - JUnit 5는 함수형 인터페이스를 매개변수로 받는 메서드(특히 `assertThrows`)를 제공해 람다 활용을 권장합니다.

- 테스트 대상 코드 내에서 함수형 인터페이스를 파라미터로 받아 테스트 시 조건이나 동작을 유연하게 변경할 수 있습니다.

- 사용자 정의 함수형 인터페이스를 만들어 테스트 로직 복잡도에 맞게 확장할 수 있습니다.

- 파라미터화 테스트와 조합해 테스트 함수형을 파라미터로 취하는 테스트를 만들면, 테스트 재사용성과 가독성이 높아집니다.

즉, JUnit에서 함수형 인터페이스와 람다를 활용하면 깔끔하고 유연한 테스트 코드를 작성할 수 있으며, Java 8 이상의 기능을 적극적으로 활용하는 모던한 테스트 방식입니다.