item39.md

ITEM 39 명명 패턴보다 에너테이션을 사용하라

명명 패턴 - JUnit3

• JUnit3 의 경우 테스트 케이스의 이름은 test 로 시작해야 한다.
• test 로 시작해야 테스트 케이스로 인식한다.
• TestCase 클래스를 상속받아야 한다.

import junit.framework.*;
 
public class TestSample extends TestCase {
       public TestSample(String name){  super(name); }
 
       public void setUp(){}
 
       public void tearDown(){}
 
		// 명명패턴 - 테스트 케이스는 test 로 시작
       public void test01(){
              //테스트 코드
       }
 
       public static Test suite (){
              return new TestSuite( TestSample.class );
       }
 
       public static void main(String args[]){
              TesrFinder.run(TestSample.class,args);
       }
}
[레필리아의 잡동사니 :: 단위테스트 JUNIT (3)]
(https://repilria.tistory.com/315)

명명패턴의 단점

• 오타가 나면 인식을 못한다.
  • 인식을 못하면 오류메세지도 뜨지 않을 것이고, 테스트가 통과했다고 잘못 인식할 수 있다.
• 의도한 곳에서만 쓰일 것이라 보장할 수 없다.
  • 사용법을 잘 모르는 사용자가 메서드가 아닌 클래스에 Test 명명패턴을 적용하고 그 클래스의 테스트 케이스들이 실행되길 기대할 수 도 있다.
• 명명 패턴에는 패턴 실행에 필요한 인자를 매개변수로 넘길 방법이 마땅치 않다.

-> 명명 패턴 대신 에너테이션을 쓰자 !

---

에너테이션 사용하기

에너테이션 세개를 만들어 보면서, 에너테이션이 무엇인지와 명명패턴의 단점을 어떻게 보완 하는지 알아보자 !

목표 : 매개변수 없는 정적 메서드에만 쓸 수 있는 테스트 에너테이션을 만들어보자 ! - Annotation Processor 를 사용해보자.

0. 새로운 프로젝트 만들기

• 새로운 프로젝트를 만들고, 적절한 groupId와 article 을 지정한다.
• 기본 생성되는 스프링의 Application 클래스와 테스트 클래스들을 삭제한다. (선택)

1. 에너테이션 만들기

/**
 * 이 에너테이션은 매개변수 없는 정적 메서드에만 달 수 있는 마커 에너테이션이다.
 */
@Retention(RetentionPolicy.SOURCE) // 컴파일 후 에너테이션 정보 사라짐
@Target(ElementType.METHOD) // 메서드에만 달 수 있음
public @interface CustomTest {
}

• 메타 에너테이션 : 에너테이션을 만들때 붙이는 에너테이션
  • @Retention : 인자로 에너테이션 정보가 언제까지 남아있을지 지정한다.
  • @Target : 인자로 해당 에너테이션이 어디에 붙어있을 수 있는지 지정한다.
• 마커 에너테이션 : 아무 매개변수 없이 단순히 마킹에 사용하는 에너테이션 (ex. @Override)

2. 에너테이션 프로세서 작성

• 에너테이션 프로세서는 에너테이션을 읽고 코드를 추가하거나 특정 작업을 할 수 있게 해준다.
• 에너테이션은 기본적으로 리플렉션을 이용하여 동작한다.

@SupportedAnnotationTypes("com.meetcoder.testannotation.CustomTest")

public class CustomTestProcessor extends AbstractProcessor {

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        Set<? extends Element> elementsAnnotatedWith = roundEnv.getElementsAnnotatedWith(CustomTest.class);
        for(Element element : elementsAnnotatedWith){
            makeErrorIfNotStaticMethod(element);
        }
        return true;
    }
    
    private void makeErrorIfNotStaticMethod(Element element) {
        if (isNotStaticMethod(element)) {
            processingEnv.getMessager().printMessage(Kind.ERROR, "static 메서드가 아닙니다.");
        }
    }
    
    private boolean isNotStaticMethod(Element element) {
        return !element.getModifiers().contains(Modifier.STATIC);
    }
}

3. compile

mvn compile (빌드도구) 로 컴파일한다.

4. resources/META-INF/services/javax.annotation.processing.Processor 파일 만들기

• 에너테이션 프로세서를 이용하기 위해서는 정해진 위치에 등록해야 한다.
• 에너테이션 프로세서를 쓰기 위해서는 다음 경로를 만들고, javax~ 파일을 만들어야 한다.
• 이 파일 안에 에너테이션 프로세서의 FQCN 을 작성한다.

(각자의 에너테이션 프로세서 경로에 맞게 작성하기 ! )

5. mvn install (빌드도구) 로 jar 파일 만들기

• pom.xml 에 필요없는 의존성과 플러그인을 삭제후 jar 파일로 만든다.

(에너테이션 하나, 에너테이션 프로세서 하나, 등록하는 리소스파일 하나)

6. 에너테이션을 사용할 프로젝트에서 의존성 추가

(방금 만든 jar 를 가져오기 위해 의존성 추)

7. 에너테이션을 사용한 후, 컴파일만 해서 오류가 뜨는지 확인

(static 이 아닌 메서드에 에너테이션 붙였을 시, 런타임이 아닌 컴파일타임에 에러가 뜬다.)

---

매개값이 있는 에너테이션

목표 : 예외가 발생하면 성공하는 테스트 에너테이션을 만들어 보자 ! 이 에너테이션은 인자값으로 에러를 지정하고, 반복 사용으로 여러 에러를 지정할 수 있어야 한다.

이번에는 메인메서드에 테스트 러너를 작성할 것이다. (에너테이션 프로세서 만들기에 실패했습니다....) 에너테이션 프로세서의 장점은 컴파일타임에 오류를 잡을 수 있다는 것이다, 테스트 러너를 만들어서 하면 런타임에 오류를 확인할 수 있다.

1. 에너테이션 생성

@Repeatable(ExceptionTestContainer.class)
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface ExceptionTest {
    Class<? extends Throwable> value();
}

• value() 라는 이름으로 지정하면 에너테이션 사용시 타입을 지정하지 않아도 됨.
• 같은 에너테이션을 여러개 달기 위해 @Repeatable() 메타 에너테이션 사용
• @Repeatable 을 사용하기 위해서는 컨테이너 클래스가 필요하다.

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface ExceptionTestContainer {
    ExceptionTest[] value();
}

2. 테스트 러너 작성

public class RunTest {

    private Class<?> testClass;
    private int tests = 0;
    private int passed = 0;

    public RunTest(String path) {
        try {
            this.testClass = Class.forName(path);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    public Class<?> getTestClass() {
        return testClass;
    }

    public void run(Class<?> runTest) {
        for (Method method : runTest.getDeclaredMethods()) {
            if (method.isAnnotationPresent(ExceptionTest.class) || method.isAnnotationPresent(ExceptionTestContainer.class)) {
                tests++;

                try {
                    method.invoke(null);
                    System.err.printf("**테스트 %s 실패 : 예외를 던지지 않았습니다 !**%n", method.getName());
                } catch (Throwable wrappedExc) {
                    Throwable exc = wrappedExc.getCause();
                    int oldPassed = passed;
                    ExceptionTest[] exceptionTests = method.getAnnotationsByType(ExceptionTest.class);

                    for (ExceptionTest exceptionTest : exceptionTests) {
                        if (exceptionTest.value().isInstance(exc)) {
                            passed++;
                            System.out.printf("**테스트 %s 에서 예상대로 %s 예외가 발생하였습니다 !**%n", method.getName(), exc.getClass());
                            break;
                        }
                    }

                    if (passed == oldPassed) {
                        System.err.printf("**테스트 %s 실패 : 다른 예외 %s 가 발생하였습니다 !**%n", method.getName(), exc.getClass());
                    }
                }
            }
        }
    }

    public static void main(String[] args) throws ClassNotFoundException {

        RunTest runTest = new RunTest("Chapter6.Day39.ExceptionTest.Tests");
        Class<?> testClass = runTest.getTestClass();
        runTest.run(testClass);
    }
}

@Repeatable 에너테이션이 붙어 에너테이션을 여러번 썼다면, 내부적으로 컨테이너 에너테이션으로 적용한다. 한번 쓴 에너테이션과 구분하기 위함이다.

• AnnotatedElement.getAnnotationsByType() : 원래 에너테이션과 컨테이너 에너테이션을 구분하지 않음. 따라서 두 경우 모두 가져옴.
• AnnotatedElement.isAnnotationPresent() : 원래 에너테이션과 컨테이너 에너테이션을 구분함. 따라서 원래 에너테이션을 이 메서드로 검사한다면 [아니다] 라고 할 것이다.

따라서 getAnnotationsByType() 으로 검사한다.

결론

• 명명패턴 단점 1 : 오타나면 인식못함
  • 에너테이션은 오타나면 컴파일조차 안된다.
• 명명패턴 단점 2 : 이상한 데에 쓸 수도 있음
  • @Target, 또는 에너테이션 프로세서에서의 검사를 통해 제한가능
• 명명패턴 단점 3 : 실행에 필요한 요소 전달이 불가
  • 에너테이션에 매개변수로 전달 가능

에너테이션 쓰자.