[Spring boot] 테스트 코드 작성 (1) - Junit을 이용한 Unit Test(단위 테스트) / Assert 메소드

Spring/Test-Driven Develop

[Spring boot] 테스트 코드 작성 (1) - Junit을 이용한 Unit Test(단위 테스트) / Assert 메소드

민돌v 2022. 1. 29. 17:58

Spring 테스트 코드 작성해보기!

Junit을 이용한 단위테스트

1) 단위 테스트란

프로그램을 작은 단위로 쪼개서 각 단위가 정확하게 동작하는지 검사하는 테스트

Development: 개발
Unit Tests (단위 테스트): 개발자 테스트
QA Testing:
- 블랙박스 테스팅
- 주로 QA 팀이 Production 환경과 유사한 환경(Stage)에서 테스팅
Production: 실 서비스 운영 환경

2) Junit 이란

Junit이란 자바 프로그래밍 언어용 단위 테스트 프레임워크 이다.
어노테이션을 기반을 테스트를 지원한다.
단정문(Assert)를 통해서 테스트 케이스의 기대값에 대해 수행 결과를 화인할 수 있다.
Junit5는 크게 Jupiter, Platform, Vintage 모듈로 구성되어있다.

Junit Jupiter

TestEngine API 구현체 - JUnit5를 구현하고 있음

Junit Platform

test를 실행하기 위한 뼈대
각종 IDE를 연동을 보조하는 역할

Junit Vintage

TestEngine 구현체 JUnit 3, 4를 구현하고 있음
JUnit 3,4 버전으로 작성된 테스트 코드를 실행할 때 사용됨
youtube 어라운드허브 스튜디오

3) Junit 사용설정

Spring boot에는 Build.gradle을 확인해보면 이미 Junit 사용을 위한 환결설정이 되어있다.

dependencies {
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

test {
    useJUnitPlatform()
}

4) 테스트 파일 생성하기

1. 파일 찾기

Windows: ctrl + shift + N
Mac: command + shifht + O

2. 테스트 코드를 작성할 파일 선택

파일 내에서 마우스 오른쪽 클릭 후 > "Generate..." 클릭

3. "Test.." 클릭 후 기본세팅 그대로 OK

4. Test 파일 생성

Test 코드 작성을 위한 파일 틀이 생성 된다!

5) Junit 어노테이션 알아보기

Junit LifeCycle 어노테이션

Junit 5는 아래와 같은 테스트 라이프 사이클을 가지고 있다.

Annotation	Description
@Test	테스트용 메소드를 표현하는 어노테이션
@BeforEach	각 테스트 메소드가 시작되기 전에, 실행되어야 하는 메소들 표현
@AfterEach	각 테스트 메소드가 시작된 후 실행되어야 하는 메소드르 표현
@BeforeAll	테스트 시작 전에 실행되어야 하는 메소드를 표현(Static 처리 필요)
@AfterAll	테스트 종료 후에 실행되어야 하는 메소드를 표현(Static 처리 필요)

Junit Main Annotation

@SpringBootTest

통합 테스트 용도로 사용됨
@SpringBootApplication을 찾아가 하위의 모든 Bean을 스캔하여 로드함
그 후 Test용 Application Context를 만들어 Bean을 추가하고, MockBean을 찾아 교체

@ExtendWith

JUnit4에서 @RunWith로 사용되던 어노테이션이 ExtendWith로 변경됨
@ExtendWith는 메인으로 실행될 Class를 지정할 수 있음
@SpringBootTest는 기본적으로 @ExtendWith가 추가되어 있음

@WebMvcTest(Class명.class)

( )안에 작성된 클래스만 실제로 로드하여 테스트를 진행
매게변수를 지정해주지 않으면 @Controller, @RestController, @RestControllerAdvice 등 컨트롤러와 연관된 Bean이 모두 로드됨
스프링의 모든 Bean을 로드하는 @SpringBootTest대신 컨트롤러 관련 코드만 테스트할 경우 사용

@Autowired about Mockbean

Controller의 API를 테스트하는 용도인 MockMvc 객체를 주입 받음
Perform()메소드를 활용하여 컨트롤러의 동작을 확인할 수있음
andExpect(), andDo(), andReturn() 등의 메소드를 같이 활용함

@MockBean

테스트할 클래스에서 주입 받고 있는 객체에 대해 가짜 객체를 생성해주는 어노테이션
해당 객체는 실제 행위를 하지 않음
given() 메소드를 활용하여 가짜 객체의 동작에 대해 정의하여 사용할 수 있음

@AutoConfigureMockMvc

spring.test.mockmvc의 설정을 로드하면서 MockMvc의 의존성을 자동으로 주입
MockMvc 클래스는 REST API 테스트를 할 수 있는 클래스

@Import

필요한 Class들을 Configuration으로 만들어 사용할 수 있음
Configuration Component 클래스도 의존성 설정할 수 있음
Import된 클래스는 주입으로 사용 가능

6) Junit 사용해보기

Junit Life Cycle 확인해보기!

//Junit Life Cycle 

class PostTest {
    @BeforeAll
    static void beforeAll() {
        System.out.println("## BeforeAll Annotation 호출 ##");
        System.out.println();
    }

    @AfterAll
    static void afterAll() {
        System.out.println("## afterAll Annotation 호출 ##");
        System.out.println();
    }

    @BeforeEach
    void beforeEach() {
        System.out.println("## beforeEach Annotation 호출 ##");
        System.out.println();
    }

    @AfterEach
    void afterEach() {
        System.out.println("## afterEach Annotation 호출 ##");
        System.out.println();
    }

    @Test
    void test1() {
        System.out.println("## test1 시작 ##");
        System.out.println();
    }

    @Test
    @DisplayName("Test Case 2!!!")
    void test2() {
        System.out.println("## test2 시작 ##");
        System.out.println();
    }

    @Test
    @Disabled
        // Disabled Annotation : 테스트를 실행하지 않게 설정하는 어노테이션
    void test3() {
        System.out.println("## test3 시작 ##");
        System.out.println();
    }
}

BeforeAll 이 제일 먼저 실행되고

beforeEach가 각 메서드가 실행되기 전 실행,

afterEach가 각 메서드 실행 후 호출

@Disabled를 만나면 함수 호출 X!

객체 생성 테스트

@Test
    @DisplayName("Post 생성 테스트")
    void CreatePost(){
        System.out.println("## Create Post 시작 ##");
        System.out.println();

        Long userId = 123456L;
        User user = new User("Test","123", UserRole.USER,"nicname");
        PostRequestDto postRequestDto = new PostRequestDto();
        postRequestDto.setTitle("test 제목");
        postRequestDto.setContent("test 내용");

        Post post = new Post(postRequestDto,user);

        assertEquals(post.getImg(),"/img/no-pic.png");
        assertEquals(post.getTitle(),"Test");
    }

assertEquals 함수를 이용해 기대값과 맞는 값이 들어가는지 테스트 해 볼 수 있다.

post 객체의 아무값도 넣어주지 않았을 때, Default 값이 잘 들어갔는지,
Post에 생성해준 title값이 올바르게 들어갔는지 등을 Assert 함수를 사용해테스트 할 수 있다,

assert메서드

assertEquals(a, b): a와 b의 값이 동일한지 확인
- ```
assertEquals(member.getName(), findMember.getName());
```
assertSame(a, b): a와 b의 객체가 동일한지 확인
assertNull(a): a가 null인지 확인
assertNotNull(a): a가 null이 아닌지 확인
assertTrue(a): a가 true인지 확인
assertFalse(a): a가 false인지 확인

assertThrows(입셉션 에러 종류 a, 발생하는 로직 b) : b 로직시에 a 입셉션이 발생하는지 확인

IllegalStateException e = assertThrows(IllegalStateException.class,
        () -> memberService.join(member2));//예외가 발생해야 한다.

assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다.");

assertThat : AssertJ 라이브러리에 포함된 메서드, 어떤 조건이 참인지 확인

import static org.assertj.core.api.Assertions.*;


IllegalStateException e = assertThrows(IllegalStateException.class,
        () -> memberService.join(member2));//예외가 발생해야 한다.

assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다.");

7) Junit 유효성 테스트 해보기

Validation 테스트 코드를 작성해보자

그전에 @Nested 어노테이션은, @Test를 그룹으로 묶어 마치 클래스처럼 사용할수 있게 만드는 어노테이션이다. (계층구조의 테스트 코드를 작성할 수 있도록 해줌)

먼저 유효성 검사 클래스를 만들고

Validation.PostValidator.class

@Component
public class PostValidator {
    public static void validatePostInput(PostRequestDto requestDto, Long userId) {
        if (userId == null || userId <= 0) {
            System.out.println(userId);
            throw new IllegalArgumentException("회원 Id 가 유효하지 않습니다.");
        }

        if (requestDto.getTitle() == null || requestDto.getTitle().isEmpty()) {
            throw new IllegalArgumentException("저장할 수 있는 상품명이 없습니다.");
        }

        if (requestDto.getContent() == null || requestDto.getContent().isEmpty()) {
            throw new IllegalArgumentException("저장할 수 있는 상품설명이 없습니다.");
        }

        if (requestDto.getImg()!=null && !MyURLValidator.isValidUrl(requestDto.getImg().toString())) {
            throw new IllegalArgumentException("상품 이미지 URL 포맷이 맞지 않습니다.");
        }
    }
}

Validation.MyURLValidator.class

public class MyURLValidator {
    public static boolean isValidUrl(String url)
    {
        try {
            new URL(url).toURI();
            return true;
        }
        catch (URISyntaxException exception) {
            return false;
        }
        catch (MalformedURLException exception) {
            return false;
        }
    }
}

객체 생성시 validation 검사를 해주고 Test시 엣지 케이스가 들어갈 때 원하는 에러 메세지를 반환하는지를 확인한다.

Domain.Post

//새로운 게시글 생성
    public Post(PostRequestDto postRequestDto, User user){
        PostValidator.validatePostInput(postRequestDto,user.getId());

        this.user = user;
        this.title = postRequestDto.getTitle();
        this.content = postRequestDto.getContent();
    }

PostTest

/*--------------Post 성공, 실패 테스트----------------*/
    @Nested
    @DisplayName("게시글 객체 생성")
    class CreateUserProduct {

        private Long userId;
        private String title;
        private String content;
        private MultipartFile img;
        private User user;

        @BeforeEach
        void setup() {
            title = "제목이야 제목테스트";
            content = "테스트 내용이지롱";
            user = new User("Test", "123", UserRole.USER, "nicname");
            user.setId(123456L);
        }

        @Test
        @DisplayName("Post 생성 정상 테스트")
        void CreatePost() {
            System.out.println("## Create Post 시작 ##");
            System.out.println();

            PostRequestDto postRequestDto = new PostRequestDto();
            postRequestDto.setTitle(title);
            postRequestDto.setContent(content);

            Post post = new Post(postRequestDto, user);

            assertEquals(post.getImg(), "/img/no-pic.png");
            assertEquals(post.getTitle(), title);
        }

        @Nested
        @DisplayName("실패 케이스")
        class FailCases {
            @Nested
            @DisplayName("회원 Id")
            class userId {
                @Test
                @DisplayName("null")
                void fail1() {
                    // given
                    user.setId(null);

                    PostRequestDto requestDto = new PostRequestDto(
                            title,
                            content
                    );

                    // when
                    Exception exception = assertThrows(IllegalArgumentException.class, () -> {
                        new Post(requestDto, user);
                    });

                    // then
                    assertEquals("회원 Id 가 유효하지 않습니다.", exception.getMessage());
                }

                @Test
                @DisplayName("마이너스")
                void fail2() {
                    // given
                    userId = -100L;
                    user.setId(userId);
                    PostRequestDto requestDto = new PostRequestDto(
                            title,
                            content
                    );

                    // when
                    Exception exception = assertThrows(IllegalArgumentException.class, () -> {
                        new Post(requestDto, user);
                    });

                    // then
                    assertEquals("회원 Id 가 유효하지 않습니다.", exception.getMessage());
                }
            }

            @Nested
            @DisplayName("상품명")
            class Title {
                @Test
                @DisplayName("null")
                void fail1() {
                    // given
                    title = null;

                    PostRequestDto requestDto = new PostRequestDto(
                            title,
                            content
                    );

                    // when
                    Exception exception = assertThrows(IllegalArgumentException.class, () -> {
                        new Post(requestDto, user);
                    });

                    // then
                    assertEquals("저장할 수 있는 상품명이 없습니다.", exception.getMessage());
                }

                @Test
                @DisplayName("빈 문자열")
                void fail2() {
                    // given
                    String title = "";

                    PostRequestDto requestDto = new PostRequestDto(
                            title,
                            content
                    );

                    // when
                    Exception exception = assertThrows(IllegalArgumentException.class, () -> {
                        new Post(requestDto, user);
                    });

                    // then
                    assertEquals("저장할 수 있는 상품명이 없습니다.", exception.getMessage());
                }
            }

            /*@Nested
            @DisplayName("상품 이미지 URL")
            class Image {
                @Test
                @DisplayName("null")
                void fail1() {
                    // given
                    img = null;

                    PostRequestDto requestDto = new PostRequestDto(
                            title,
                            content
                    );

                    // when
                    Exception exception = assertThrows(IllegalArgumentException.class, () -> {
                        new Post(requestDto, user);
                    });

                    // then
                    assertEquals("상품 이미지 URL 포맷이 맞지 않습니다.", exception.getMessage());
                }
            }*/
        }

이렇게 Test 코드를 작성해 보았다...

다음엔. Mock 객체?? 그거를 한번 공부해볼까 한다..하하

끝!!

*참고

youtube 어라운드허브 스튜디오 : https://www.youtube.com/watch?v=SFVWo0Z5Ppo

assert 메소드 : https://jforj.tistory.com/48

스파르타 코딩클럽 강의 자료

저작자표시

티스토리