AssertJ 기본 문법 정리

spring boot 를 사용하다보면 자동으로 

org.assertj.core.api 를 추가해준다.

 

그래서 다음과 같이 static import 해야 사용하기 편리하다

 

 

 

 

메서드명과 코드를 보면 쉽게 이해할 수 있으니 캡쳐로 충분히 이해할 수 있다

 

 
import org.assertj.core.api.SoftAssertions;
import org.junit.jupiter.api.Test;
 
import java.io.IOException;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
import static org.assertj.core.api.Assertions.*;
 
public class AssertJ_Test {
 
    @Test
    public void 값이_같은지_검증() throws Exception {
 
        int number = 1;
        // 실제값, 기대값
        assertThat(number).isEqualTo(1);
    }
 
    @Test
    public void 값이_다른지_검증() throws Exception {
 
        int number = 1;
        // 실제값, 기대값
        assertThat(number).isNotEqualTo(10);
    }
 
    @Test
    public void null_인지_검증() throws Exception {
 
        String isNull = null;
 
        // 실제값, 기대값
        assertThat(isNull).isNull();
 
    }
    
    @Test
    public void null이_아닌지_검증() throws Exception {
 
        String isNotNull = "나는존재한다";
 
        // 실제값, 기대값
        assertThat(isNotNull).isNotNull();
 
    }
 
    @Test
    public void 값_목록에_포함되는지_검증() throws Exception {
 
        int number = 1;
        List<Integer> list = List.of(1, 2, 3, 4, 5, 6);
 
        // 실제값, 기대값
        assertThat(number).isIn(list);
 
    }
 
    @Test
    public void 값_목록에_포함_되지_않는지_검증() throws Exception {
 
        int number = 10;
        List<Integer> list = List.of(1, 2, 3, 4, 5, 6);
 
        // 실제값, 기대값
        assertThat(number).isNotIn(list);
 
    }
 
    @Test
    public void 값보다_작은지_검증() throws Exception {
 
        int number = 10;
 
        // 실제값, 기대값
        assertThat(number).isLessThan(100);
 
    }
    
    @Test
    public void 값보다_작은지_검증2() throws Exception {
 
 
        int nowYear = LocalDate.now().getYear();
        int afterYear = LocalDate.now().plusYears(5L).getYear();
 
        // 실제값, 기대값
        assertThat(nowYear).isLessThan(afterYear);
 
    }
 
    @Test
    public void 값보다_작은지_검증3() throws Exception {
 
        LocalDateTime localDateTime = LocalDateTime.now();
 
        ZonedDateTime zonedDateTime = LocalDateTime.now().plusDays(15).atZone(ZoneId.systemDefault());
 
        Date nowDate = new Date();
        Date afterDate = Date.from(zonedDateTime.toInstant());
 
 
        // 실제값, 기대값
        assertThat(nowDate.getTime()).isLessThan(afterDate.getTime());
 
    }
    
    @Test
    public void 값보다_작거나_같은지_검증() throws Exception {
 
 
        // 실제값, 기대값
        // => 10 은 20보다 작거나 같다
        assertThat(10).isLessThanOrEqualTo(20);
 
    }
 
    @Test
    public void 값보다_큰지_검증() throws Exception {
 
 
        // 실제값, 기대값
        // => 20 은 10 보다 크다
        assertThat(20).isGreaterThan(10);
 
    }
 
    @Test
    public void 값보다_크거나_같은지_검증() throws Exception {
 
 
        // 실제값, 기대값
        // => 20 은 20 보다 크거나 같다
        assertThat(20).isGreaterThanOrEqualTo(20);
 
    }
 
    @Test
    public void 값_A와_값_B_사이에_포함된다() throws Exception {
 
 
        // 실제값, 기대값
        // => 값 50은 1과 100사이에 포함된다
        assertThat(50).isBetween(1, 100);
 
    }
    
    @Test
    public void True_인지_검증() throws Exception {
 
        LocalDateTime localDateTime = LocalDateTime.now();
 
        ZonedDateTime zonedDateTime = LocalDateTime.now().plusDays(15).atZone(ZoneId.systemDefault());
 
        Date nowDate = new Date();
        Date afterDate = Date.from(zonedDateTime.toInstant());
 
 
        // 실제값, 기대값
        // nowDate 가 afterDate 보다 과거이냐?
        assertThat(nowDate.before(afterDate)).isTrue();
 
    }
 
    @Test
    public void False_인지_검증() throws Exception {
 
        LocalDateTime localDateTime = LocalDateTime.now();
 
        ZonedDateTime zonedDateTime = LocalDateTime.now().plusDays(15).atZone(ZoneId.systemDefault());
 
        Date nowDate = new Date();
        Date afterDate = Date.from(zonedDateTime.toInstant());
 
 
        // 실제값, 기대값
        // afterDate 가 nowDate 보다 과거이냐?
        assertThat(afterDate.before(nowDate)).isFalse();
 
    }
 
    /**
     * String
     */
    @Test
    public void 문자열을_다_포함_하는지_검증() throws Exception {
 
 
        // 실제값, 기대값
        // "피자나라치킨공주" 글자에는 "피자"와 "치킨"이라는 글자가 포함된다
        assertThat("피자나라치킨공주").contains("피자", "치킨");
 
    }
 
    @Test
    public void 해당_문자열이_딱_한번만_존재_하는지_검증() throws Exception {
 
 
        // 실제값, 기대값
        // "피자나라치킨공주" 글자에는 "피자" 라는 글자가 딱 한번만 포함된다
        assertThat("피자나라치킨공주").containsOnlyOnce("피자");
 
    }
 
 
    @Test
    public void 문자열에_오직_숫자만_있는지_검증() throws Exception {
 
 
        String phone = "01012345678";
 
        // 실제값, 기대값
        // phone 이라는 문자열 변수에 오직 숫자로 이루어져 있다
        assertThat(phone).containsOnlyDigits();
 
    }
    
    @Test
    public void 문자열에_공백이_있는지_검증() throws Exception {
 
 
        String text = "white space";
 
        // 실제값, 기대값
        // text 이라는 문자열 변수에 공백 문자가 포함된다
        assertThat(text).containsWhitespaces();
 
    }
    
    @Test
    public void 공백_으로만_이루어진_문자열_인지_검증() throws Exception {
 
 
        String whiteSpaceText = "             ";
 
        // 실제값, 기대값
        // whiteSpaceText 이라는 문자열 변수는 공백문자로만 이루어져 있다
        assertThat(whiteSpaceText).containsOnlyWhitespaces();
 
    }
 
    @Test
    public void 정규_표현식을_만족하는지_검증() throws Exception {
 
 
        String phone = "01012345678";
 
        // 실제값, 기대값
        // phone 이라는 문자열 변수는 숫자로만 이루어져 있다
        assertThat(phone).containsPattern("^[0-9]+$");
 
    }
 
    @Test
    public void 문자열이_글자를_포함하지_않는지_검증() throws Exception {
 
 
        String foodNames = "치킨과피자";
 
        // 실제값, 기대값
        // foodNames 이라는 문자열 변수는 "햄버거", "스파게티" 라는 글자가 없다
        assertThat(foodNames).doesNotContain("햄버거", "스파게티");
 
    }
 
    @Test
    public void 공백_문자_를_포함하지_않은지_검증() throws Exception {
 
 
        String foodNames = "치킨과피자";
 
        // 실제값, 기대값
        // foodNames 이라는 문자열 변수는 공백문자가 없다
        assertThat(foodNames).doesNotContainAnyWhitespaces();
 
    }
 
    @Test
    public void 공백_문자_로만_이루어진_문자가_아닌지_검증() throws Exception {
 
 
        String message = "Hello            ";
 
        // 실제값, 기대값
        // message 이라는 문자열 변수는 공백문자로만 이루어져 있지 않다 (즉, 글자가 있다)
        assertThat(message).doesNotContainOnlyWhitespaces();
 
    }
    
    @Test
    public void 정규_표현식을_만족하지_않는지_검증() throws Exception {
 
 
        String phone = "홍길동01012345678";
 
        // 실제값, 기대값
        // phone 이라는 문자열 변수는 숫자로만 이루어져 있지 않다
        assertThat(phone).doesNotContainPattern("^[0-9]+$");
 
    }
    
    @Test
    public void 특정_문자로_시작_하는지_검증() throws Exception {
 
 
        String frameWork = "spring data jpa";
 
        // 실제값, 기대값
        // frameWork 이라는 문자열 변수는 "spring" 이라는 글자로 시작한다
        assertThat(frameWork).startsWith("spring");
 
    }
 
    @Test
    public void 특정_문자로_시작_하지_않는지_검증() throws Exception {
 
 
        String application = "egov spring application";
 
        // 실제값, 기대값
        // application 이라는 문자열 변수는 "spring" 이라는 글자로 시작한다
        assertThat(application).doesNotStartWith("spring");
 
    }
    
    @Test
    public void 특정_문자로_끝나는지_하는지_검증() throws Exception {
 
 
        String frameWork = "spring data jpa";
 
        // 실제값, 기대값
        // frameWork 이라는 문자열 변수는 "jpa" 이라는 글자로 끝난다
        assertThat(frameWork).endsWith("jpa");
 
    }
    
    @Test
    public void 특정_문자로_끝나지_않는지_검증() throws Exception {
 
 
        String application = "egov spring application";
 
        // 실제값, 기대값
        // application 이라는 문자열 변수는 "egov" 이라는 글자로 끝나지 않는다
        assertThat(application).doesNotEndWith("egov");
 
    }
 
 
    /**
     * 숫자에 대한 추가 검증
     */
 
    @Test
    public void 값이_0_인지_검증() throws Exception {
 
        int zeroCount = 0;
 
        // 실제값, 기대값
        // zeroCount 은 0 이다
        assertThat(zeroCount).isZero();
 
    }
    
    @Test
    public void 값이_0_이_아닌지_검증() throws Exception {
 
        int count = 10;
 
        // 실제값, 기대값
        // count 은 0 이 아니다
        assertThat(count).isNotZero();
 
    }
 
    @Test
    public void 값이_0_이_양수_인지_검증() throws Exception {
 
        int age = 132;
 
        // 실제값, 기대값
        // age 은 양수이다
        assertThat(age).isPositive();
        assertThat(age).isNotNegative();
 
    }
 
    @Test
    public void 값이_0_이_음수_인지_검증() throws Exception {
 
        int myCash = -1;
 
        // 실제값, 기대값
        // myCash 은 음수이다
        assertThat(myCash).isNotPositive();
        assertThat(myCash).isNegative();
 
    }
 
 
    /**
     * 날짜에 대한 검증
     */
    @Test
    public void 비교할_값_보다_이전_날짜_인지_검증() throws Exception {
 
        LocalDateTime nowDateTime = LocalDateTime.now();
        LocalDateTime afterDateTime = LocalDateTime.of(2030, 12, 31, 23, 59, 59);
 
        // 실제값, 기대값
        // nowDateTime 은 afterDateTime 보다 이전이다
        assertThat(nowDateTime).isBefore(afterDateTime);
 
 
    }
 
    @Test
    public void 비교할_값_보다_이전_이거나_같은_날짜_인지_검증() throws Exception {
 
        LocalDateTime nowDateTime = LocalDateTime.now();
        LocalDateTime afterDateTime = LocalDateTime.of(
                nowDateTime.getYear(),
                nowDateTime.getMonthValue(),
                nowDateTime.getDayOfMonth(),
                nowDateTime.getHour(),
                nowDateTime.getMinute(),
                nowDateTime.getSecond(),
                nowDateTime.getNano()
        );
        LocalDateTime beforeDateTime = LocalDateTime.now().minusDays(1);
 
        // 실제값, 기대값
        // nowDateTime 은 afterDateTime 보다 이전 이거나 같다
        assertThat(nowDateTime).isBeforeOrEqualTo(afterDateTime);
 
        // beforeDateTime 은 nowDateTime 보다 이전 이거나 같다
        assertThat(beforeDateTime).isBeforeOrEqualTo(nowDateTime);
 
 
    }
 
    @Test
    public void 비교할_값_보다_이후_날짜_인지_검증() throws Exception {
 
        LocalDateTime nowDateTime = LocalDateTime.now();
        LocalDateTime afterDateTime = LocalDateTime.now().plusDays(10);
 
        // 실제값, 기대값
        // afterDateTime 은 nowDateTime 보다 이후 이다(미래)
        assertThat(afterDateTime).isAfter(nowDateTime);
 
 
    }
 
    @Test
    public void 비교할_값_보다_이후_이거나_같은_날짜_인지_검증() throws Exception {
 
        LocalDateTime nowDateTime = LocalDateTime.now();
 
        LocalDateTime afterDateTime = LocalDateTime.now().plusYears(1);
 
        // 실제값, 기대값
 
        // afterDateTime 은 nowDateTime 보다 이후 이거나 같다
        assertThat(afterDateTime).isAfterOrEqualTo(nowDateTime);
 
 
    }
 
 
    @Test
    public void 날짜_의_특정_칼럼_을_제외하고_나머지_값이_같은지_검증() throws Exception {
 
        LocalDateTime nowDateTime = LocalDateTime.now();
 
        LocalDateTime beforeDateTime1 = LocalDateTime.now().minusNanos(1);
        LocalDateTime beforeDateTime2 = LocalDateTime.now().minusSeconds(1);
        LocalDateTime beforeDateTime3 = LocalDateTime.now().minusMinutes(1);
        LocalDateTime beforeDateTime4 = LocalDateTime.now().minusHours(1);
 
        // 실제값, 기대값
 
        // nowDateTime 은 beforeDateTime1 의 나노초를 제외한 시간대는 같다
        assertThat(nowDateTime).isEqualToIgnoringNanos(beforeDateTime1);
 
        // nowDateTime 은 beforeDateTime2 의 초 이하를 제외한 시간대는 같다
        assertThat(nowDateTime).isEqualToIgnoringSeconds(beforeDateTime2);
 
        // nowDateTime 은 beforeDateTime3 의 분 이하를 제외한 시간대는 같다
        assertThat(nowDateTime).isEqualToIgnoringMinutes(beforeDateTime3);
 
        // nowDateTime 은 beforeDateTime3 의 시간 이하를 제외한 시간대는 같다
        assertThat(nowDateTime).isEqualToIgnoringHours(beforeDateTime4);
 
 
 
    }
 
    /**
     * 컬렉션에 대한 검증
     */
 
    // List Or Set
    @Test
    public void 컬렉션의_크기가_기대한_값과_같은지_검증() throws Exception {
 
        List<Integer> list = List.of(1, 2, 3, 4, 5);
 
        // 실제값, 기대값
        // list 은 크기가 5 이다
        assertThat(list).hasSize(5);
 
 
    }
 
    @Test
    public void 컬렉션이_해당_값을_포함_하는지_검증() throws Exception {
 
        List<Integer> list = List.of(1, 2, 3, 4, 5);
 
        // 실제값, 기대값
        // list 은 1,2,3 을 포함한다
        assertThat(list).contains(1, 2, 3);
 
 
    }
 
    @Test
    public void 컬렉션이_지정한_값만_포함_하는지_검증() throws Exception {
 
        List<Integer> list = List.of(1, 2, 3, 4);
 
        // 실제값, 기대값
        // list 은 정확히 1,2,3,4 만 가지고 있다
        assertThat(list).containsOnly(1, 2, 3, 4);
 
 
    }
 
 
    @Test
    public void 컬렉션이_지정한_값의_일부를_포함_하는지_검증() throws Exception {
 
        List<Integer> list = List.of(1, 2, 3, 4);
 
        // 실제값, 기대값
        // list 은 1, 3, 5, 7, 9 중에 일부를 포함한다 (1, 3)
        assertThat(list).containsAnyOf(1, 3, 5, 7, 9);
 
    }
 
    @Test
    public void 컬렉션이_지정한값을_딱_한번만_포함_하는지_검증() throws Exception {
 
        List<Integer> list = List.of(1, 2, 3, 4);
 
        // 실제값, 기대값
        // list 은 1, 3 을 딱 한번만 포함한다
        assertThat(list).containsOnlyOnce(1,3);
 
    }
 
 
    // Map
    @Test
    public void Map이_지정한_키를_포함_하는지_검증() throws Exception {
 
        Map<String, Object> map = new HashMap<>();
        map.put("age", 132);
        map.put("name", "ksj");
 
 
        // 실제값, 기대값
        // map 은 age 라는 키를 가지고 있다
        assertThat(map).containsKey("age");
 
    }
 
    @Test
    public void Map이_지정한_키들을_포함_하는지_검증() throws Exception {
 
        Map<String, Object> map = new HashMap<>();
        map.put("age", 132);
        map.put("name", "ksj");
 
 
        // 실제값, 기대값
        // map 은 age, name 라는 키들을 가지고 있다
        assertThat(map).containsKeys("age", "name");
 
    }
 
 
 
    @Test
    public void Map이_지정한_키만_포함_하는지_검증() throws Exception {
 
        Map<String, Object> map = new HashMap<>();
        map.put("age", 132);
        map.put("name", "ksj");
//        map.put("name2", "ksj");
 
 
        // 실제값, 기대값
        // map 은 age, name 라는 키들만 가지고 있다
        assertThat(map).containsOnlyKeys("age", "name");
 
    }
 
 
    @Test
    public void Map이_지정한_키를_포함_하지_않는지_검증() throws Exception {
 
        Map<String, Object> map = new HashMap<>();
        map.put("age", 132);
        map.put("name", "ksj");
 
 
        // 실제값, 기대값
        // map 은 title 라는 키를 갖지 않는다
        assertThat(map).doesNotContainKey("title");
 
    }
 
    @Test
    public void Map이_지정한_키들을_포함_하지_않는지_검증() throws Exception {
 
        Map<String, Object> map = new HashMap<>();
        map.put("age", 132);
        map.put("name", "ksj");
 
 
        // 실제값, 기대값
        // map 은 title 라는 키를 갖지 않는다
        assertThat(map).doesNotContainKeys("title", "content");
 
    }
 
    @Test
    public void Map이_지정한_엔트리_포함_하는지_검증() throws Exception {
 
        Map<String, Object> map = new HashMap<>();
        map.put("age", 132);
        map.put("name", "ksj");
 
        Map.Entry<String, Integer> entry = Map.entry("age", 132);
 
        // 실제값, 기대값
        // map 은 Map.entry("age", 132) 라는 엔트리를 갖는지 검증
        assertThat(map).contains(entry);
 
    }
 
    @Test
    public void Map이_지정한_엔트리_포함_하는지_검증2() throws Exception {
 
        Map<String, Object> map = new HashMap<>();
        map.put("age", 132);
        map.put("name", "ksj");
 
        // 실제값, 기대값
        // map 은 키는 "age" 이고 값은 132 인 엔트리를 갖는지 검증
        assertThat(map).containsEntry("age", 132);
 
    }
 
    /**
     * 익셉션 관련 검증
     */
    @Test
    public void 익셉션이_발생_하는지_검증() throws Exception {
 
        assertThatThrownBy(() -> {
            throw new IllegalArgumentException();
        });
 
    }
 
    @Test
    public void 해당_타입의_익셉션이_발생_하는지_검증() throws Exception {
 
        assertThatThrownBy(() -> {
            throw new IllegalArgumentException();
        }).isInstanceOf(RuntimeException.class);
 
    }
 
    @Test
    public void 해당_타입의_익셉션이_발생_하는지_검증_두번째_방법() throws Exception {
 
 
        assertThatExceptionOfType(RuntimeException.class)
                .isThrownBy(() -> {
                    throw new IllegalArgumentException();
                });
    }
 
    @Test
    public void IOException_익셉션이_발생_하는지_검증() throws Exception {
 
        assertThatIOException().isThrownBy(() -> {
            throw new IOException();
        });
 
    }
 
    @Test
    public void 익셉션이_발생_하지_않는지_검증() throws Exception {
 
        assertThatCode(() -> {
            // code...
            System.out.println("예외가 발생하지 않습니다");
        }).doesNotThrowAnyException();
 
    }
 
    @Test
    public void 여러_검증을_모아서_검증하기() throws Exception {
 
        // 테스트가 실패해야 정상, 실패했을때 나오는 콘솔을 확인
 
        SoftAssertions soft = new SoftAssertions();
        soft.assertThat(1).isEqualTo(1);
        soft.assertThat(10).isGreaterThan(20);  // <- 거짓
        soft.assertThat(10).isGreaterThan(30);  // <- 거짓
        soft.assertThat("1234567890").containsOnlyDigits();
        soft.assertAll();
 
 
    }
 
    @Test
    public void 여러_검증을_모아서_검증하기_두번째_방법() throws Exception {
 
        // 테스트가 실패해야 정상, 실패했을때 나오는 콘솔을 확인
 
        SoftAssertions.assertSoftly((soft) -> {
            soft.assertThat(1).isEqualTo(1);
            soft.assertThat(10).isGreaterThan(20);  // <- 거짓
            soft.assertThat(10).isGreaterThan(30);  // <- 거짓
            soft.assertThat("1234567890").containsOnlyDigits();
        });
 
    }
 
    /**
     * 테스트 설명달기
     */
    @Test
    public void 테스트에_설명_달기_1() throws Exception {
 
        // 실패해야 정상
        assertThat(1)
                .as("1은 양의 정수이다")
                .isNegative();
    }
 
    @Test
    public void 테스트에_설명_달기_2() throws Exception {
 
        String message = "1은 양의 정수이다";
 
        // 실패해야 정상
        assertThat(1)
                .as("[정수 검사] %s", message)
                .isNegative();
    }
    
    @Test
    public void 테스트에_설명_달기_3() throws Exception {
 
 
        // 실패해야 정상
        assertThat(1)
                .describedAs("1은 양의 정수이다")
                .isNegative();
    }
 
    @Test
    public void 테스트에_설명_달기_4() throws Exception {
 
 
        // 실패해야 정상
        String message = "1은 양의 정수이다";
 
        // 실패해야 정상
        assertThat(1)
                .describedAs("[정수 검사] %s", message)
                .isNegative();
    }
 
}