[Spring] Junit5을 이용한 테스트 코드 작성

class StudyTest {

    @Test
    void create() {
        Study study = new Study();
        assertNotNull(study);
        System.out.println("create");
    }

    @Test
    void create1() {
        System.out.println("create1");
    }

    // 모든 테스트 메소드 실행 전 한번만 작동 하는 어노테이션
    // 반드시 static 을 붙여야 하며 리턴 타입은 void
    @BeforeAll
    static void beforeAll() {
        System.out.println("before all");
    }

    // 모든 테스트 메소드 실행 전 한번만 작동 하는 어노테이션
    @AfterAll
    static void afterAll() {
        System.out.println("after all");
    }

    // 각각 테스트 메소드를 실행하기 전에 작동하는 어노테이션
    @BeforeEach
    void beforeEach() {
        System.out.println("before Each");
    }

    // 각각 테스트 메소드를 실행한 후에 작동하는 어노테이션
    @AfterEach
    void afterEach() {
        System.out.println("after Each");
    }
}

@DisplayNameGeneration(DisplayNameGenerator.ReplaceUnderscores.class)
class StudyTest {

    @Test
    void create_new_study() {
    }

// 실행 결과에 create new study 로 표기됨 ( 언더바 제거된 이름) 

    @Test
    @DisplayName("스터디 만들기")
    void create_new_study() {
    }

// study 오브젝트 처음 상태가 DFAFT인지 확인 하고 있고
// 아래와 같이 같지 않다면 메세지를 출력해 줄 수도 있다. 

Study study = new Study();
assertEquals(StudyStatus.DRAFT, study.getStudyStatus(),
                () -> "스터디를 처음 만들면 상태가 DRAFT 여야 함" );   

assertAll(
        () -> assertEquals(StudyStatus.START, study.getStudyStatus(),
                    () -> "스터디를 처음 만들면 상태가 DRAFT 여야 함" ),

        () -> assertEquals(StudyStatus.END, study.getStudyStatus(),
                    () ->"스터디를 처음 만들면 상태가 DRAFT 여야 함")
        );

IllegalArgumentException exception =
        assertThrows(IllegalArgumentException.class , () -> new Study(-10));
        System.out.println(exception.getMessage());

// 100 mills 안에 들어오는지 확인
assertTimeout(Duration.ofMillis(100), () -> {
            Thread.sleep(300); // 100 mills 보다 크기때문에 false
        });

// 메소드 마다 개별적으로 테스트 하여 테스트 별로 의존성을 줄이는게 좋은 테스트 방법 이지만
// 메소드 마다 각각 인스턴스를 생성해야 하므로 하나의 인스턴스를 이용하여 테스트해야 하는 경우에는 
// 테스트 생명주기를 클래스 단위로 설정 할 수 있다.
@TestInstance(TestInstance.Lifecycle.PER_CLASS) // 테스트 생명 주기를 클래스 단위로 설정
@TestMethodOrder(MethodOrderer.OrderAnnotation.class) // 메소드 마다 순서를 정할 수 있음
@DisplayName("Github API 테스트")
class GithubApiTest {

    private GithubApi api;


    @Test
    @Order(1) // 숫자가 적을 수록 우선순위가 높다
    @DisplayName("Github API 객체 생성 테스트")
    void createInstance() throws IOException {

        api = new GithubApi();
        assertNotNull(api);

    }

    @Test
    @Order(2)
    @DisplayName("ISSUE객체를 받아온다.")
    void setIssue() {

        List<GHIssue> issues = api.getIssues();

        assertThat(issues.size()).isGreaterThan(0);
    }
}

@Test
  void createStudyService() {

     MemberService memberService = Mockito.mock(MemberService.class);
     assertNotNull(memberService);
}

@ExtendWith(MockitoExtension.class)
class StudyServiceTest {
    @Mock
    MemberService memberService;
    @Test
    void createStudyService() {
        assertNotNull(memberService);
    }
}

@ExtendWith(MockitoExtension.class)
class StudyServiceTest {

    @Test
    void createStudyService(@Mock MemberService memberService) {
        assertNotNull(memberService);
    }
}

@ExtendWith(MockitoExtension.class)
class StudyServiceTest {

    @Mock MemberService memberService;

    @Test
    void createStudyService() {

        Member member = new Member();
        member.setId(1L);
        member.setEmail("wonyong@naver.com");

        // Stubbing
        // 매개변수 1로 받았을때 member 객체를 리턴 시켜 주는 걸로 정의한다.
        when(memberService.findById(1L)).thenReturn(Optional.of(member));

        // 매개변수 2로 받았을 때는 예외를 발생 시킨다.   
        when(memberService.findById(2L)).thenThrow(new RuntimeException());

        // 위에서 Stubbing 했기 때문에 매개변수 1을 검색해보면 member 객체를 리턴받는 것을 확인 할 수 있다.  
        Optional<Member> member1 = memberService.findById(1L);

        assertEquals("wonyong@naver.com", member1.get().getEmail());
    }
}

// Argument matchers 검색해 볼 것 
when(memberService.findById(any())).thenReturn(Optional.of(member));

// memberService의 void 메소드인 validate에 2값이 들어왔을때는 예외를 발생시킨다.   
doThrow(new IllegalArgumentException()).when(memberService).validate(2L);

assertThrows(IllegalArgumentException.class,() -> {
           memberService.validate(2L);
        });

when(memberService.findById(1L))
                .thenReturn(Optional.of(member))   // 첫번째 실행 결과 
                .thenThrow(IllegalArgumentException.class) //두번째 실행 결과 
                .thenReturn(Optional.empty()); // 세번째 실행 결과   

// memberSerivce 라는 Mock 객체에서 notify 라는 함수가 1번이 호출되는지 확인
verify(memberService,times(1)).notify(result);

// validate라는 메소드는 어떤 값이 오더라도 한번도 안쓰고 있어야 참
verify(memberService, never()).validate(any());

// 순서를 확인할 Mock 객체
InOrder inOrder = inOrder(memberService);

inOrder.verify(memberService).notify(result); // 첫번째로 발생 해야함   
inOrder.verify(memberService).notify(member); // 두번째로 발생 해야함  

// 100 ms
verify(mock, timeout(100)).someMethod();

// 100ms 안에 1번 메소드 호출되야 한다.   
verify(memberService,timeout(100).times(1)).notify(member);

// memberSerivce 라는 Mock 객체에서 notify 라는 함수가 1번이 호출되는지 확인   
verify(memberService,times(1)).notify(result);   
verifyNoInteractions(memberService); // 위에 메소드 이후에 호출 되면 안된다.