테스트 데이터도구 - Fixture Monkey

 

아직 출시된지 얼마 안되어 사용을 추천하는 단계는 아니지만, 알아두면 좋기에 정리해둡니다.

Fixture Monkey를 만든 네이버 페이 팀에서는 잘 사용하고 있다고 합니다. 

네이버페이 개편 TF를 함께하고 있는 Platform Labs에서 만든 도구이고, 사내에서 실제로 사용중이라고 합니다.

영상을 보니 아직 출시되지않은 새로운 기능이 굉장히 탐나는데, 빨리 안정화 되었으면 좋겠네요 😀 

 

레퍼런스 : https://tv.naver.com/v/23650158

테스트 객체는 엣지 케이스까지 찾아주는 Fixture Monkey에게 맡기세요

 

💭 PBT, 테스트 데이터를 자동으로 만들어주는 도구

테스트를 작성하면서 제일 번거로운 것이 테스트 데이터를 만드는 것이다.

성공하는 테스트 데이터는 만들기 쉽지만, 실패하는 건 만들기도 귀찮고 누락될 확률도 높다.

 

심지어는 아래와 같이 생성자나 내부 필드를 변경한 경우에도 모든 테스트 데이터가 컴파일이 불가능하게 바뀐다.

객체의 생성자, 필드를 변경하면 테스트가 깨지곤 한다.

그냥 객체의 필드를 기반으로 알아서 테스트 데이터를 생성할 수는 없을까?

➡ 이게 바로 PBT (Property Based Testing) 도구이다.

 

다른언어(C#)에서는 유명한 PBT 도구들이 많지만, 자바에서는 아직 대중화된 도구가 많이 없다. 그나마 쓸만한 오픈소스가 AutoParms, Fixture Monkey 정도인데, 네이버페이에서 개발했다는 Fixture Monkey에 대해서 알아보자.

 

 

---

💭 Fixture Monkey

Fixture Monkey는 네이버페이에서 만든 PBT 오픈소스 도구이다. 자바의 PBT 도구인 Jqwik 을 기반으로 만들어졌다.

Gradle이나 Maven을 사용하고 있다면, 아래와 같이 간단하게 바로 추가할 수 있다.
🧨 Java8+, Junit5, jqwik 1.3.9 를 사용한다.

testImplementation("com.navercorp.fixturemonkey:fixture-monkey-starter:0.3.2")

<dependency>
    <groupId>com.navercorp.fixturemonkey</groupId>
    <artifactId>fixture-monkey-starter</artifactId>
    <version>0.3.2</version>
    <scope>test</scope>
</dependency>

 

기본적으로 자바/Junit5를 지원하며 필요에 따라 아래와 같은 서드파티 모듈들을 사용할 수 있다.

• fixture-monkey-jackson (공식): 테스트에서 jackson을 통한 객체 직렬화/역직렬화를 지원합니다.
• fixture-monkey-kotlin (공식): 코틀린 지원
• fixture-monkey-autoparams (베타 버전): 다른 PBT 오픈소스인 AutoParams 과의 연동을 지원합니다.
• fixture-monkey-mockito (베타 버전): 모킹 도구인 mockito의 목 객체 생성/인터페이스를 지원합니다.

testImplementation("com.navercorp.fixturemonkey:fixture-monkey-kotlin:0.3.2")
testImplementation("com.navercorp.fixturemonkey:fixture-monkey-jackson:0.3.2")
testImplementation("com.navercorp.fixturemonkey:fixture-monkey-autoparams:0.3.2")
testImplementation("com.navercorp.fixturemonkey:fixture-monkey-mockito:0.3.2")

 

Jqwik이 뭐죠? 이게 기능이 좋다면 그냥 바로 쓰면 되잖아요?

Jqwik은 기능은 다양했지만, 실제 서비스에 적용하기엔 Jqwik을 따로 공부해야될 정도로 코드 작성이 번거로웠다.

또한 테스트에서 필요한 무작위 값을 만들기도 어려웠고, List[List[String]] 같은 제네릭 컬렉션은 지원해주지 않았다.

@RequiredArgsConstructor
class Person { // 테스트 대상 객체
    private final String name;
    private final int age;
}

@Property // 테스트 코드
void validPeopleHaveIDs(@ForAll("validPeople") Person aPerson) {
    Assertions.assertThat(aPerson.getID()).contains("-");
    Assertions.assertThat(aPerson.getID().length()).isBetween(5, 24);
}

@Provide // 테스트에 필요한 속성 정의
Arbitrary<Person> validPeople() {
    Arbitrary<String> names = Arbitraries.strings().withCharRange('a', 'z')
        .ofMinLength(3).ofMaxLength(21);
    Arbitrary<Integer> ages = Arbitraries.integers().between(0, 130);
    return Combinators.combine(names, ages)
        .as((name, age) -> new Person(name, age));
}

---

 

 

어떻게 사용하나요?

Fixture Monkey는 자바의 표준 Bean Validation 2.0 어노테이션(JSR-303, JSR-380)을 사용한다.

쉽게 말해, 아래와 같이 표준 어노테이션을 통해 테스트용 객체를 생성한다는 말. 전용 어노테이션이 필요하지 않다.

@Test
void test() {
    // FixtureMonkey 빌더를 생성한다.
    FixtureMonkey sut = FixtureMonkey.create();

    // 빌더를 이용하여 테스트 객체를 생성한다.
    Order actual = sut.giveMeOne(Order.class);

    then(actual.getId()).isNotNull(); // @NotNull
	then(actual.getOrderNo()).isNotBlank(); // @NotBlank
	then(actual.getProductName().length()).isBetween(2, 10); // @Size(min = 2, max = 10)
	then(actual.getQuantity()).isBetween(1, 100); // @Min(1) @Max(100)
	then(actual.getPrice()).isGreaterThanOrEqualTo(0); // @Min(0)
	then(actual.getItems()).hasSizeLessThan(3); // @Size(max = 3)
	then(actual.getItems()).allMatch(it -> it.length() <= 10); // @NotBlank @Size(max = 10)
    then(actual.getOrderedAt()).isBeforeOrEqualTo(Instant.now()); // @PastOrPresent
}

 

이 테스트에 사용된 Person 객체코드는 아래와 같다. (Fixture Monkey와 관련된 의존성이나 코드가 하나도 없다!)

@Data   // lombok getter, setter
public class Order {
    @NotNull
    private Long id;

    @NotBlank
    private String orderNo;

    @Size(min = 2, max = 10)
    private String productName;

    @Min(1)
    @Max(100)
    private int quantity;

    @Min(0)
    private long price;

    @Size(max = 3)
    private List<@NotBlank @Size(max = 10) String> items = new ArrayList<>();

    @PastOrPresent
    private Instant orderedAt;
}

 

---

💭 자세한 사용법

참고로 Arbitray 라는 용어가 많이 사용되는데, 이는 랜덤의, 임의의, 멋대로의 라는 뜻을 가지고 있다.

 

📌 FixtureMonkey 생성하기

- FixtureMonkey.create()를 사용해서 손쉽게 데이터 빌더를 생성할 수 있다.

기본 생성 전략은 BeanArbiyraryGenerator 로 자바빈즈 규칙에 따라 Getter, Setter를 이용해서 생성한다.
즉, 따로 설정을 하지 않는다면 Getter Setter가 없을 때 예외가 발생하므로, 생성 전략을 바꿔주어야한다.

FixtureMonkey sut = FixtureMonkey.create();

Order actual = sut.giveMeOne(Order.class);
List<Order> orders = sut.giveMe(Order.class, 5); // 5개

 

특별한 설정이 필요하다면 giveMeBuilder를 통해 빌더 객체로 커스텀할 수 있다. (AribitrayBuilder가 반환된다.)

Order actual = sut.giveMeBuilder(Order.class)
    .generator(JacksonArbitraryGenerator.INSTANCE) // 생성 전략 지정
    .set("name", "factory")
    .set("quantity", Arbitraries.integers().between(5, 10))
    .sample(); // Order를 복사해서 생성한다. 원본을 건드리지 않는다.

 

설정은 테스트 메서드에서 매번 할 수도 있지만, FixtureMonkey를 필드(private final)로 뽑아서 재사용하는 걸 권장한다.

private final FixtureMonkey fixtureMonkey = FixtureMonkey.builder()
    .defaultGenerator(JacksonArbitraryGenerator.INSTANCE) // Jackson 규칙 사용
    .build();

 

 

 

📌 객체 생성 전략 (ArbitrayGenerator)

참고로 개발자가 직접 커스텀 생성 전략을 만들 수 있다. 물론 직접 만들일은 거의 없긴 하지만.

 

BeanArbitraryGenerator(기본)

자바빈즈 규칙, 매개변수가 없는 기본 생성자와 Setter를 사용한다. 

@Setter
@NoArgsConstructor
public class Person {
    private Long id;
    private String name;
}

 

만약 순수한 자바코드인데, 생성자 주입을 하고싶다면 ConstructorPropertiesArbitraryGenerator 을 사용하면 된다.

이는 Java Bean의 표준 @ConstructorProperties 어노테이션을 사용해서 객체를 생성하는 방법이다.

public class Product{ 
    private Long id;
    private String name;
    
    @ConstructorProperties({"id", "name"}) 
    public Person(Long id, String name) { 
        this.id = id;
        this.name = name; 
    }
}

 

BuilderArbitraryGenerator (Lombok @Builder)

Lombok 의 @Builder를 기반으로 생성한다.

예제처럼 빌더 이름을 따로 지정한 경우, BuilderArbitraryGenerator.setbuilderMethodName 등을 지정해주어야한다.

@Builder
public class Person {
	private Long id;
	private String name;
}

@Builder(builderMethodName = "builder2", buildMethodName = "build2")
public class Order {
	private Long id;
	private String name;
}

// 빌더 이름 지정하는 방법
var generator = BuilderArbitraryGenerator.INSTANCE;
generator.setBuilderMethodName(Order.class, "myBuilderName");
generator.setDefaultBuilderMethodName("myDefaultBuilderName");

FixtureMonkey fixtureMonkey = FixtureMonkey.builder()
    .defaultGenerator(generator)
    .build();

 

FieldReflectionArbitraryGenerator (리플랙션)

리플랙션을 통해 객체를 생성한다. 스프링 프록시나 JPA Entity 와 비슷하다. 

필드가 없는 public 기본생성자가 필요하며, 필드 접근제어자는 상관없지만 final, transient 가 선언된 건 만들 수 없다.

@Entity
@NoArgsConstructor(access = AccessLevel.PACKAGE)
@AllArgsConstructor
public class Person {
    @Id
    private Long id;
    private String name;
}

 

JacksonArbitraryGenerator (FixtureMonkey.Jaskson 모듈 필요)

testImplementation("com.navercorp.fixturemonkey:fixture-monkey-jackson:0.3.0")

Jackson을 이용해서 객체를 생성해준다. 해당 빌더를 사용하면 Jackson 어노테이션을 추가로 지원한다.

 

@Data   // lombok getter, setter
public class Order {
    @NotNull
    private Long id;

    @JsonProperty("name")
    private String productName;

    private int quantity;
    
    @JsonIgnore
    private String sample;
}

@Test
void test() {
    // given
    FixtureMonkey sut = FixtureMonkey.create();

    // when
    Order actual = sut.giveMeBuilder(Order.class)
        .generator(JacksonArbitraryGenerator.INSTANCE)
        .set("name", "factory")
        .set("quantity", Arbitraries.integers().between(5, 10)) // 이는 뒤에서 설명한다
        .sample();

    // then
    then(actual.getId()).isNotNull();    // @NotNull
    then(actual.getProductName()).isEqualTo("factory");
    then(actual.getQuantity()).isBetween(5, 10);
    then(actual.getSample()).isNull();  // @JsonIgnore
}

 

---

📌 ArbitrayCustomizer - 람다식으로 객체 데이터 생성하기

FixtureCustomizer<Person> personAgeFixedCustomizer = person -> {
                                                        person.setAge(20);
                                                        return person;
                                                    }; // 람다식으로 커스터마이저 정의

Person person20Age = fixture.giveMeBuilder(Person.class)
    .customize(p -> { // 이렇게 Customizer 익명객체(람다)를 바로 정의해서 사용할 수 있다.
        p.setAge(20);
        return p;
    })
    .sample();

 

추천하는 방법은 아니지만, 람다식을 안쓰고 직접 AbitraryCustomizer를 상속하여 구현하는 방법도 있습니다.

class PersonArbitraryCustomizer implements ArbitraryCustomizer<Person> {
    @Override
    public void customizeFields(Class<Person> type, FieldArbitraries fieldArbitraries) {
        fieldArbitraries.removeArbitrary("id");   
        fieldArbitraries.replaceArbitrary("name", Arbitraries.strings().ofMaxLength(30));   
        ....
    }

    @Nullable
    @Override
    public Person customizeFixture(@Nullable Person person) {
        person.setAge(20); 
        return person;
    }
}

FixtureMonkey fixture = FixtureMonkey.builder().build();

Person person20Age = fixture.giveMeBuilder(Person.class)
    .customize(p -> {
        p.setAge(20);
        return p;
    })
    .sample();

// 이렇게 전달해도 똑같이 동작한다.
Person person = fixture.giveMeBuilder(Person.class)
    .customize(new PersonFixtureCustomizer())
    .sample();

List<Person> persons = fixture.giveMeBuilder(Person.class)
    .customize(new PersonFixtureCustomizer())
    .sampleList(3);

 

 

---

📌 다양한 필드 생성 (giveMeOne, giveMeBuilder)

위에도 언급했지만, 예제처럼 매번 FixtureMonkey를 만들기보단 private final 필드로 뽑아서 쓰는걸 권장한다.

 

함수를 체인해서 설정을 하고싶다면, giveMeBuilder() 메서드를 통해 ArbitraryBuilder를 받아서 사용하면 된다.

// 임의 객체 생성
Sample sample = FixtureMonkey.create().giveMeOne(Sample.class);

// 임의 객체 생성
Sample sample = FixtureMonkey.create().giveMeBuilder(Sample.class).sample();

// 임의 객체 생성 n개 생성
Sample sample = FixtureMonkey.create().giveMe(Sample.class, n);

// 임의 객체 생성 n개 생성
Sample sample = FixtureMonkey.create().giveMeBuilder(Sample.class).sampleList(n);

// 특정 조건 또는 값을 가진 임의 객체 생성
Sample sample = FixtureMonkey.create().giveMeBuilder(Sample.class)
    .set("name", "test")
    .setNull("id")
    .sample();

// 임의 Integer 생성
Integer listCount = FixtureMonkey.create().giveMeOne(Integer.class);

// 1~50 사이 임의 Interger 생성
// .set("$", Arbitraries.integers().between(1, 50)) 이 코드와 같은 동작이다.
Integer listCount =
    FixtureMonkey.create()
        .giveMeBuilder(Integer.class)
        .set(Arbitraries.integers().between(1, 50))
        .sample();
        
        

// 임의 String 생성
String parameter = FixtureMonkey.create().giveMeOne(String.class);

// min=1 의 임의 String 생성
// .set("$", Arbitraries.strings().ofMinLength(1)) 와 같은 동작이다.
String parameter =
    FixtureMonkey.create()
        .giveMeBuilder(String.class)
        .set(Arbitraries.strings().ofMinLength(1))
        .sample();

 

---

📌 Mockito와 연동 (베타, 실험적 기능)

테스트 데이터에 인터페이스와 추상클래스가 있는 경우, 자동으로 Mockito의 MockBean을 주입시켜주는 기능이다.

 

아래 모듈을 추가해주어야 한다.

testImplementation("com.navercorp.fixturemonkey:fixture-monkey-mockito:0.3.0")

 

아래와 같이 Item 의존성을 주입해줘야하는 경우, 해당 기능을 이용해 Mockito의 MockBean을 주입해줄 수 있다.

public interface Item {
    String getName();
}

@Data   // lombok getter, setter
public class Order {

    @NotNull
    private Long id;

    private String productName;

    private int quantity;

    @NotNull
    private Item item; // 인터페이스. 주입이 필요하다.
}

 

사용법은 간단하다. InterfaceSupplier를 추가해주고, Mockito로 검증하면 된다.

@Test
void test() {
	// given
	FixtureMonkey sut = FixtureMonkey.builder()
		.defaultInterfaceSupplier(MockitoInterfaceSupplier.INSTANCE)
		.build();

    // when
    Order actual = sut.giveMeOne(Order.class);

    // then
    then(actual.getItem()).isNotNull();
    
    when(actual.getItem().getName()).thenReturn("ring");
    then(actual.getItem().getName()).isEqualTo("ring");
}

 

---

📌 실전 예제

Builder에 전달한 객체는 그대로 사용되지않고 복사해서 새롭게 생성한다.

즉 아래와 같이 필드로 뽑아두고, 다른 테스트에 재사용할 수 있다.

// 이것도 매번 만들 필요없이, 필드로 뽑아두면 더 깔끔하게 사용 가능
private final FixtureMonkey fixture = FixtureMonkey.builder()
    .defaultGenerator(JacksonArbitraryGenerator.INSTANCE)
    .build();

private final Order orderFixture = new Order(
    1L,
    "LINE FRIENDS",
    1000L,
    List.of(
        new Product("SALLY", 300L),
        new Product("BROWN", 300L)
    ),
    List.of(new Coupon(100L)),
    new Delivery("그린팩토리", null, true, 500L),
    Instant.now()
);

이렇게 만든 객체를 이용해 직접 테스트를 해보자.

@Test
void test_with_fixture() {
    // 미리 만들어둔 객체를 이용하면, 고정된 값을 사용할 수 있다.
    var order = fixture.giveMeBuilder(orderFixture)
        .set("delivery.road", false) // 해당 데이터에서 road = false 변경
        .setNull("delivery.detailAddress") // 해당 데이터에서 detailAddress = null 변경
        .sample(); // 인스턴스 복사

    log.info("📌 Test Data :: {}", order.toString());

    thenThrownBy(() -> orderService.validateDeliveryAddress(order))
        .isExactlyInstanceOf(MyDomainException.class);
}

해당 인스턴스의 값을 복사해서 들어간다.

 

물론 무작위 값을 넣고싶다면 따로 만들 필요 없이 그냥 Order.class를 박으면 된다.

@Test
void test_with_class_token() {
    // 설정하지 않은 다른 값들은 랜덤한 값이 들어간다.
    var order = fixtureMonkey.giveMeBuilder(Order.class)
        .set("delivery.road", false)
        .setNull("delivery.detailAddress")
        .sample();

    log.info("\n\n 📌 Test Data :: {}", order.toString());

    thenThrownBy(() -> orderService.validateDeliveryAddress(order))
        .isExactlyInstanceOf(MyDomainException.class);
}

테스트용 무작위의 데이터가 들어간다.

 

📌 추천하는 사용방법

매번 FixtureMonkey를 정의하기보단, 그냥 아래와 같은 정적 빌더메서드를 추가하는걸 권장한다.

public abstract class MonkeyUtils {
  public static FixtureMonkey monkey() {
    return FixtureMonkey.builder()
        .defaultGenerator(FieldReflectionArbitraryGenerator.INSTANCE)
        .defaultInterfaceSupplier(MockitoInterfaceSupplier.INSTANCE)
        .build();
  }
}

class SampleRepositoryTest {
  @Autowired private SampleRepository sampleRepository;

  @Test
  void create() {
    Sample sample = MonkeyUtils.monkey()
            .giveMeBuilder(Sample.class)
            .setNull("id") // 리플랙션 주입이라, private 뚫기 가능
            .sample();

    Sample entity = sampleRepository.save(sample);

    Assertions.assertNotNull(entity.getId());
  }
}