1101 - 1107

1101 - HTTP API와 REST API

HTTP API와 REST API는 사실 거의 같은 의미로 사용된다.
하지만 디테일하게 들어가면 차이가 있다.

• HTTP API는 HTTP를 사용해서 서로 정해둔 스펙으로 데이터를 주고 받으면 통신하는 것, 상당히 넓은 의미로 사용
• 반면, REST API는 HTTP API에 여러가지 제약 조건이 추가된다.
  • 자원의 식별
  • 메세지를 통한 리소스 조작
  • 자기서술적 메세지
  • 애플리케이션의 상태에 대한 엔진으로서 하이퍼미디어

여러가지가 있지만 대표적으로 구현하기 어려운 부분이 마지막 부분이다. 이것은 HTML처럼 하이퍼링크가 추가되어서 다음에 어떤 API를 호출해야 하는지를 해당 링크를 통해서 받을 수 있어야 한다.

그리고 이런 부분을 완변하게 지키면서 개발하는 것을 RESTful API라고 한다. 실무에서 이런 방법으로 갭라하는 것은 현실적으로 어렵고, 또 추가 개발 비용대비 효과가 부족하다.

그런데 이미 많은 사람들이 해당 조건을 지키지 않아도 REST API라고 하기 때문에, HTTP API나 REST API를 거의 같은 의미로 사용하고 있다. 하지만 앞서 이야기한 것 처럼 엄격하게 위의 내용들을 모두 지켜야 RESTful한 API라고 할 수 있다.

1102 - 자바 var 키워드

Java 10에서 도입된 var는 변수를 선언할 때 타입을 생략할 수 있으며, 컴파일러가 타입을 추론한다.

다음과 같이 변수를 선언하면 컴파일러가 String 타입을 추론하여 번수에 타입을 지정해 준다. Kotlin과 같이 타입 출론을 지원하는 언어와 같이 지원한다.

var string = "Hello, World";

• 컴파일 타임에 추론하는 것이기 때문에, Runtime에 추가 연산을 하지 않아 성능에 영향을 주지는 않는다.
• Java에서 var는 지역 변수에서만 사용할 수 있따. 또한 컴파일러가 타입을 추론할 수 없는 애매한 상황일 때 컴파일 에러가 발생한다.

var로 변수 선언

• Java 9이하

String str = "Hello, World";

• Java 10

var str = "Hello, World";

if(str instanceof String) {
    System.out.println("This is a String : " + str);
}

// This is a String : Hello, World

다른 클래스들도 var로 변수를 선언할 수 있다.

var list = new ArrayList<String>();

if (list instanceof ArrayList) {
    System.out.println("This is a ArrayList");
}

// This is a ArrayList

여기서 list는 ArrayList타입으로 선언되며, var list = new ArrayList();로 선언하면 타입은 ArrayList

반복문에서 사용

int[] arr = {1, 2, 3};

for (var n : arr) {
    System.out.println("n : " + n);
}

// n : 1
// n : 2
// n : 3

제약 사항

• 지역 변수에서만 사용
• 초기화 필요
• null로 초기화할 수 없음
• 배열에 사용할 수 없음
• Lambda에 사용할 수 없음

1103 - BigDecimal

자바는 IEEE 754 부동 소수점 방식을 사용하기 떄문에
정확한 실수를 저장하지 않고 최대한 완벽에 가깝기를 바라는 근사치 값을 저장한다.

따라서 금융권에서 달러를 다루는 개발자가 double을 이용한다면 문제가 발생할 수 있다.

이러한 문제를 해결하기위해 부동 소숫점 방식이 아닌, 정수를 이용해 실수를 표현하는 java.math.BigDecimal클래스를 사용한다.

BigDecimal이란?

• BigDecimal은 Java 언어에서 숫자를 정밀하게 저장하고 표현할 수 있는 유일한 방법이다.
• 소수점을 저장할 수 있는 가장 크기가 큰 타입인 double은 소수점의 정밀도에 한계까 있어 값이 유실될 수 있다.
• Java 언어에서 돈과 소수점을 다룬다면 BigDecimal은 선택이 아니라 필수이다.
• BigDecimal의 유일한 단점은 느린 속도와 기본 타입보다 조금 불편한 사용법 이다.

double, 무엇이 문제인가?

• 소수점 이하의 수를 다룰 때 double 타입은 사칙연산시 기대 값과 다른 값을 출력한다. 이유는 double 타입이 내부적으로 수를 저장할 때 이진수의 근사치를 저장하기 때문이다. 저장된 수를 다시 십진수로 표현하면서 아래와 같은 문제가 발생한다. BigDecimal 타입은 내부적으로 수를 십진수로 저장하여 아주 작은 수와 큰 수의 연산에 대해 거의 무한한 정밀도를 보장한다.

double a = 10.0000;
double b = 3.0000;

// 기대값: 13
// 실제값: 13.000001999999999
a + b;

// 기대값: 7
// 실제값: 6.999999999999999
a - b;

// 기대값: 30
// 실제값: 30.000013000000997
a * b;

// 기대값: 3.33333...
// 실제값: 3.333332555555814
a / b;

BigDecimal 사용

BigDecimal 기본 용어

• precision : 숫자를 구성하는 전체 자리수라고 생각하면 편하나, 정확하게 풀이하면 왼쪽부터 0이 아닌 수가 시작하는 위치부터 오른쪽부터 0이 아닌 수로 끝나는 위치까지의 총 자리수이다. unscale과 동의어이다. (ex: 012345.67890의 precision은 11이 아닌9이다.)
• scale : 전체 소수점 자리수라고 생각하면 편하나, 정확하게 풀이하면 소수점 첫쨰 자리부터 오른쪽부터 0이 아닌 수로 끝나는 위치까지의 총 소수점 자리수이다. fraction과 동의어이다. (ex: 012345.67890의 scale은 4이다. 하지만 0.00, 0.0의 scale은 모두 1이다.) BigDecimal은 32bit의 소수점 크기를 가진다.
• DECIMAL128: IEEE 754-2008에 의해 표준화된, 부호와 소수점을 수용하며, 최대 34자리까지 표현 가능한 10진수를 저장할 수 있는 형식이다. 2018년 미국 정부의 총 부채액이 15조 7천 500억 달러로 총 14자리 임을 감안하면, 금융권에서 처리되는 대부분의 금액을 수용할 수 있는 크기이다. Java에서는 BigDecimal 타입을 통해 공식적으로 지원한다.

BigDecimal 기본 상수

• float, double 타입과 다르게 BigDecimal 타입은 초기화가 장황한 편이다. 그래서, 자주 쓰는 0, 1, 100은 쓰기 편하게 미리 상수로 정의되어 있다.

// 흔히 쓰이는 값은 상수로 정의
// 0
BigDecimal.ZERO

// 1
BigDecimal.ONE

// 10
BigDecimal.TEN

BigDecimal 초기화

• double 타입으로 부터 BigDecimal 타입을 초기화하는 방법으로 가장 안전한 것은 문자열의 형태로 생성자에 전달하여 초기화 하는 것이다. double 타입의 값을 그대로 전달할 경우 앞서 사칙연산 결과에서 본 것과 같이 이진수의 근사치를 가지게 되어 예상과 다른 값을 얻을 수 있다.

// double 타입을 그대로 초기화하면 기대값과 다른 값을 가진다.
// 0.01000000000000000020816681711721685132943093776702880859375
new BigDecimal(0.01);

// 문자열로 초기화하면 정상 인식
// 0.01
new BigDecimal("0.01");

// 위와 동일한 결과, double#toString을 이용하여 문자열로 초기화
// 0.01
BigDecimal.valueOf(0.01);

BigDecimal 비교 연산

• BigDecimal은 기본 타입이 아닌 오브젝트이기 때문에 특히, 동등 비교 연산을 유의해야 한다. double 타입을 사용하던 습관대로 무의식적으로 == 기호를 사용하면 예기치 않은 연산 결과를 초래할 수 있다.

BigDecimal a = new BigDecimal("2.01");
BigDecimal b = new BigDecimal("2.010");

// 객체의 레퍼런스 주소에 대한 비교 연산자로 무의식적으로 값의 비교를 위해 사용하면 오동작
// false
a == b;

// 값의 비교를 위해 사용, 소수점 맨 끝의 0까지 완전히 값이 동일해야 true 반환
// false
a.equals(b);

// 값의 비교를 위해 사용, 소수점 맨 끝의 0을 무시하고 값이 동일하면 0, 적으면 -1, 많으면 1을 반환
// 0
a.compareTo(b);

BigDecimal 사칙 연산

• Java에서 BigDecimal 타입의 사칙 연산 방법은 아래와 같다. 보다시피 double 타입보다 장황하고 귀찮은 편이다.

BigDecimal a = new BigDecimal("10");
BigDecimal b = new BigDecimal("3");

// 더하기
// 13
a.add(b);

// 빼기
// 7
a.subtract(b);

// 곱하기
// 30
a.multiply(b);

// 나누기
// 3.333333...
// java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.
a.divide(b);

// 나누기
// 3.333
a.divide(b, 3, RoundingMode.HALF_EVEN);

// 나누기 후 나머지
// 전체 자리수를 34개로 제한
// 1
a.remainder(b, MathContext.DECIMAL128);

// 절대값
// 3
new BigDecimal("-3").abs();

// 두 수 중 최소값
// 3
a.min(b);

// 두 수 중 최대값
// 10
a.max(b);

BigDecimal 소수점 처리

• RoundingMode.HALF_EVEN은 Java의 기본 반올림 정책으로 금융권에서 사용하는 Bankers Rounding와 동일한 알고리즘이다. 금융권에서는 시스템 개발시 혼란을 막기 위해 요구사항에 반올림 정책을 명확히 명시하여 개발한다.

// 소수점 이하를 절사한다.
// 1
new BigDecimal("1.1234567890").setScale(0, RoundingMode.FLOOR);

// 소수점 이하를 절사하고 1을 증가시킨다.
// 2
new BigDecimal("1.1234567890").setScale(0, RoundingMode.CEILING);
// 음수에서는 소수점 이하만 절사한다.
// -1
new BigDecimal("-1.1234567890").setScale(0, RoundingMode.CEILING);

// 소수점 자리수에서 오른쪽의 0 부분을 제거한 값을 반환한다.
// 0.9999
new BigDecimal("0.99990").stripTrailingZeros();

// 소수점 자리수를 재정의한다.
// 원래 소수점 자리수보다 작은 자리수의 소수점을 설정하면 예외가 발생한다.
// java.lang.ArithmeticException: Rounding necessary
new BigDecimal("0.1234").setScale(3);

// 반올림 정책을 명시하면 예외가 발생하지 않는다.
// 0.123
new BigDecimal("0.1234").setScale(3, RoundingMode.HALF_EVEN);

// 소수점을 남기지 않고 반올림한다.
// 0
new BigDecimal("0.1234").setScale(0, RoundingMode.HALF_EVEN);
// 1
new BigDecimal("0.9876").setScale(0, RoundingMode.HALF_EVEN);

BigDecimal 나누기 처리

BigDecimal b10 = new BigDecimal("10");
BigDecimal b3 = new BigDecimal("3");

// 나누기 결과가 무한으로 떨어지면 예외 발생
// java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.
b10.divide(b3);

// 반올림 정책을 명시하면 예외가 발생하지 않음
// 3
b10.divide(b3, RoundingMode.HALF_EVEN);

// 반올림 자리값을 명시
// 3.333333
b10.divide(b3, 6, RoundingMode.HALF_EVEN);

// 3.333333333
b10.divide(b3, 9, RoundingMode.HALF_EVEN);

// 전체 자리수를 7개로 제한하고 HALF_EVEN 반올림을 적용한다.
// 3.333333
b10.divide(b3, MathContext.DECIMAL32);

// 전체 자리수를 16개로 제한하고 HALF_EVEN 반올림을 적용한다.
// 3.333333333333333
b10.divide(b3, MathContext.DECIMAL64);

// 전체 자리수를 34개로 제한하고 HALF_EVEN 반올림을 적용한다.
// 3.333333333333333333333333333333333
b10.divide(b3, MathContext.DECIMAL128);

// 전체 자리수를 제한하지 않는다.
// java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result. 예외가 발생한다.
b10.divide(b3, MathContext.UNLIMITED);

BigDecimal 문자열 변환 출력

• .setScale()을 사용하여 소수점 자리수를 제한하면 원본의 소수점 값은 상실해 버린다. 문자열로 출력하는 것이 목적이라면 NumberFormat 클래스를 사용하는 것이 적합하다.

NumberFormat format = NumberFormat.getInstance();
format.setMaximumFractionDigits(6);
format.setRoundingMode(RoundingMode.HALF_EVEN);
// 0.123457
format.format(new BigDecimal("0.1234567890"));

MySQL과 BigDecimal

• MySQL 또한 Java와 동일한 문제를 가지고 있다. FLOAT, DOUBLE 타입에 소수를 가진 수를 저장할 경우 앞서와 동일한 연산의 정확도 문제가 발생한다. 이를 해결하기 위해 DECIMAL 타입을 제공한다.

foo DECIMAL(5,2) DEFAULT 0.00 NOT NULL

• DECIMAL 타입 선언시 괄호 안의 숫자의 의미는 PRECISION, SCALE을 의미한다. (5,2)의 경우 전체 자리수는 5, 소수점 이하 자리수는 2로 선언하겠다는 의미이다. 기본으로 (10,0)이 적용된다. PRECISION의 최대값은 65로 산업 표준인 DECIMAL128을 충분히 수용할 수 있다. SCALE의 최대값은 30으로 PRECISION보다 클 수 없다.
• 만약, 지정된 소수 자리수보다 많은 값을 저장할 경우, 지정된 소수 자리수 이하는 절사(floor)된다.

JPA에서의 BigDecimal 처리

• JDBC에서 MySQL/MariaDB의 DECIMAL 타입은 ResultSet 인터페이스의 getBigDecimal(), getString() 2개 메서드로 획득이 가능하다. JPAㄷ 또한 별도의 작업 없이 엔티티 필드에 BigDecimal 타입을 사용하여 처리하면 된다.
• 만약, 데이터베이스 저장시 소수점 이하 자리수와 반올림 방법을 자동으로 처리되게 하고 싶다면 JPA가 제공하는 커스텀 컨버터를 제작하면 된다.

BigDecimal과 Java Stream

// POJO 목록에서 BigDecimal 타입을 가진 특정 필드의 합을 반환
BigDecimal sumOfFoo = fooList.stream()
    .map(FooEntity::getFooBigDecimal)
    .filter(foo -> Objects.nonNull(foo))
    .reduce(BigDecimal.ZERO, BigDecimal::add);

// 특정 BigDecimal 필드를 기준으로 오름차순 정렬된 리스트를 반환
foolist.stream()
    .sorted(Comparator.comparing(it -> it.getAmount()))
    .collect(Collectors.toList());

// 위와 동일한 기능, 정렬된 새로운 리스트를 반환하지 않고 원본 리스트를 바로 정렬
foolist.sort(Comparator.comparing(it -> it.getAmount()));

https://jsonobject.tistory.com/466

1104 - 정적 팩토리 메서드(static factory method)

개요

객체 생성을 캡슐화하는 기법이다.
좀 더 구체적으로는 객체를 생성하는 메소드를 만들고, static으로 선언하는 기법이다.
자바로 코딩할 때 흔하게 볼 수 있는 valueOf 메서드가 정적 팩토리 메서드의 한 예라 할 수 있다.

BigInteger answer = BigInteger.valueOf(42L); // BigInteger 42를 리턴한다

static으로 선언된 메서드이며, new BigInteger(...)를 은닉하고 있다는 사실을 알 수 있다.
valueOf 외에, 정적 팩토리 메서드의 이름으로 흔히 사용되는 것들은 다음과 같다.

• valueOf
• of
• getInstance
• newInstance
• getType
• newType

Effective Java

이펙티브 자아 2판은 "규칠 1"에서 이 기법을 소개하고 있다.
규칙 1. 생성자 대신 정적 팩터리 메서드를 사용할 수 없는지 생각해보라.

• 단, GoF의 디자인 패턴 책에 나오는 팩토리 메서드 패턴과는 다른 패턴이다. 이름만 비슷하다.
• Effective Java 저자 조슈야 블로흐도 GoF의 디자인 패턴 책에 나온 어떤 패턴과도 맞아 떨어지지 않는다며 주의하라고 말함.

Effective Java에서는 다음과 같은 장단점을 설명한다.

• 장점
  1. 이름이 있으므로 생성자에 비해 가독성이 좋다.
  2. 호출할 때마다 새로운 객체를 생성할 필요가 없다.
  3. 하위 자료형 객체를 반환할 수 있다.
  4. 형인자 자료형(parameterized type) 객체를 만들 때 편하다.
• 단점
  1. 정적 팩토리 메서드만 있는 클래스라면, 생성자가 없으므로 하위 클래스를 못 만든다.
  2. 정적 팩토리 메서드는 다른 정적 메서드와 잘 구분되지 않는다.(문서만으로 확인하기 어려울 수 있음)

정적 팩토리 메서드 특징

• 가독성이 좋다.

class Character {

    int intelligence, strength, hitPoint, magicPoint;

    public Character(int intelligence, int strength, int hitPoint, int magicPoint) {
        this.intelligence = intelligence;   // 지능
        this.strength = strength;           // 힘
        this.hitPoint = hitPoint;           // HP
        this.magicPoint = magicPoint;       // MP
    }

    // 정적 팩토리 메소드
    public static Character newWarrior() {
        return new Character(5, 15, 20, 3);     // 전사는 힘과 HP가 높다
    }

    // 정적 팩토리 메소드
    public static Character newMage() {
        return new Character(15, 5, 10, 15);    // 마법사는 지능과 MP가 높다
    }
}

// 정적 팩토리 메서드
Character warrior = Character.newWarrior();
Character mage = Character.newMage();

// 생성자
Character warrior = new Character(5, 15, 20, 3);
Character mage = new Character(15, 5, 10, 15);

• 호출할 때마다 새로운 객체를 생성할 필요가 없다.
  사실 위와 같이 마법사와 전사를 만드는 코드는 정적 메서드를 호출할 때마다 new Character(...)를 호출하게 된다.
  그러나 immutable 객체를 캐시해서 쓰고 있다면 굳이 일일이 new 같은 비싼 연산을 사용할 필요가 없다.
  java.math.BigInteger.valueOf 예제

public static final BigInteger ZERO = new BigInteger(new int[0], 0);

private final static int MAX_CONSTANT = 16;
private static BigInteger posConst[] = new BigInteger[MAX_CONSTANT+1];
private static BigInteger negConst[] = new BigInteger[MAX_CONSTANT+1];

static {
    /* posConst에 1 ~ 16까지의 BigInteger 값을 담는다. */
    /* negConst에 -1 ~ -16까지의 BigInteger 값을 담는다. */
}

public static BigInteger valueOf(long val) {
    // 미리 만들어둔 객체를 리턴한다
    if (val == 0)
        return ZERO;
    if (val > 0 && val <= MAX_CONSTANT)
        return posConst[(int) val];
    else if (val < 0 && val >= -MAX_CONSTANT)
        return negConst[(int) -val];

    // 새로운 객체를 만들어 리턴한다
    return new BigInteger(val);
}

• 하위 자료형 객체를 반환할 수 있다. 리턴하는 객체의 타입을 유연하게 지정할 수 있다.
  다음은 어느 가상의 인터넷 쇼핑몰에서 할인 코드를 처리하는 정적 팩토리 메서드이다.

class OrderUtil {

    public static Discount createDiscountItem(String discountCode) throws Exception {
        if(!isValidCode(discountCode)) {
            throw new Exception("잘못된 할인 코드");
        }
        // 쿠폰 코드인가? 포인트 코드인가?
        if(isUsableCoupon(discountCode)) {
            return new Coupon(1000);
        } else if(isUsablePoint(discountCode)) {
            return new Point(500);
        }
        throw new Exception("이미 사용한 코드");
    }
}

class Coupon extends Discount { }
class Point extends Discount { }

할인 코드의 규칙에 따란 Coupon과 point 객체를 선택적으로 리턴하고 있다.
이를 위해서는 두 하위 클래스가 같은 인터페이스를 구현하거나, 같은 부모 클래스를 갖도록 하면 된다. 만약 파일을 분리하기 애매한 작은 클래스가 있다면 private class를 활용할 수도 있다.

다음은 java.util.Collections에서 EMPTY_MAP부분을 발췌한 것

@SuppressWarnings("rawtypes")
public static final Map EMPTY_MAP = new EmptyMap<>();

/**
 * Returns an empty map (immutable).  This map is serializable.
 */
@SuppressWarnings("unchecked")
public static final <K,V> Map<K,V> emptyMap() {
    return (Map<K,V>) EMPTY_MAP;
}

private static class EmptyMap<K,V> extends AbstractMap<K,V> implements Serializable {
    /* 생략 */
}

EmptyMap 클래스는 java.util.Collections 내에 private static으로 선언되었으며, emptyMap이라는 정적 팩토리 메서드를 통해 캐스팅된 인스턴스를 얻을 수 있다.

• 형인자 자료형 객체를 만들 때 편리하다 Java 1.7이전에는 다음과 같이 형인자 자료형 객체를 만들어야 했다.

Map<String, List<String>> list = new HashMap<String, List<String>>();

// 정적 팩토리 메서드: type inference를 이용한다
public static <K, V> HashMap<K, V> newInstance() {
    return new HashMap<K, V>();
}

// 위의 정적 팩토리 메서드를 사용한다
Map<String, List<String>> list = HashMap.newInstance();

// Java 1.7 이후
Map<String, List<String>> list = new HashMap<>();

Java 1.7부터 형인자 없이 생성이 가능하게 되어서, 의미를 거의 잃었다.

• Lombok RequiredArgsConstructor.staticName의 사용 Lombok의 RequiredArgsConstructor를 사용하면 정적 팩토리 메소드를 쉽게 만들 수 있다.

import lombok.RequiredArgsConstructor;

//                                      ↓ 정적 팩토리 메소드 이름
@RequiredArgsConstructor(staticName = "of")
public class BlogUser {
  private final Long id;
  private final String name;
}

BlogUser user = BlogUser.of(1L, "JohnGrib");

위와 같이 staticName을 선언하면 롬복이 of라는 이름을 가진 정적 팩토리 메소드를 만들어준다.

1105 - Fixture와 Mock

Test Fixture

Fixture는 '고정되어 있는 물체'를 의미

Junit 팀에서 말하는 테스트 픽스처란?

의역하자면, 테스트 실행을 위해 베이스라인으로서 사용되는 객체들의 고정된 상태이다. 테스트 픽스처의 목적은 결과를 반복가능 할 수 있도록 알 수 있고, 고정된 환경에서 테스트할 수 있음을 보장하기 위함이다.

예시

• 목 또는 가짜 객체의 세팅이나 생성 그리고 삽입할 데이터의 준비
• 구체적이며 알고있는 데이터를 지닌 데이터베이스 로딩
• 테스트 픽스처를 만들어내는 특정 파일들을 복사하면 특정 상태로 초기화된 객체들이 생성됨.

Junit은 테스트 클래스들이 매번 테스트 실행 전/후 아니면 한번만 픽스처를 가질 수 있도록 애노테이션으로 제공한다.(Junit4이 제공하는 4가지 픽스처 애노테이션: @Before, @BeforeClass, @After, @AfterClass)

Mock, Mocking

주로 객체 지향 프로그래밍으로 개발한 프로그램을 테스트 할 경우 테스트를 수행할 모듈과 연결되는 외부의 다른 서비스나 모듈들을 실제 사용하는 모듈을 사용하지 않고 실제의 모듈을 "흉내"내는 "가짜"모듈을 작성하여 테스트의 효용성을 높이는데 사용하는 객체이다. 사용자 인터페이스(UI)나 데이터베이스 테스트 등과 같이 자동화된 테스트를 수행하기 어려울 때 널리 사용된다.

Mocking

Mocking은 유닛 테스트에서 주로 사용된다.

테스트 하는 객체는 보통 다른 객체들과 의존성을 가지고 있다. 원하는 객체의 행동을 고립시키기 위해(의존성 없이) 다른 객체들을 실제 객체의 행동을 시뮬레이션하는 mock으로 대체 시켜야한다.

이는 실제 객체를 단위 테스트에 통합하기에 실용적이지 않을 때 유용하다

간략히 말해, Mocking이란 실제 객체들의 행동을 시뮬레이션하는 객체들을 만드는 것이다.

1106 - REST Assured

Java 클래스의 동작을 확인하는 Unit 테스트 수행은, 테스트 전략의 첫 단계이다.
개별 Java클래스가 독릭접으로 잘 작동한다고 해서 모든 클래스가 함께 묶일 때 어플리케이션 자체가 올바르게 작동한다는 것은 아니다.

기본 단위테스트 외에도 통합테스트(모듈에 초점을 맞춘 테스트), 기능 테스트(배포된대로 어플리케이션을 사용하는 end-to-end 테스트), 사용자 승인 테스트(GUI 테스트)가 있다.

REST Assured란?

REST Assured는 REST 웹 서비스를 검증하기 위한 Java 라이브러리
HTTP endpoint에 대한 연결 및 예상되는 결과를 설명하는 친숙한 DSL(Domain Specific Languages)을 제공한다.

• 예제

import org.junit.Test;
import io.restassured.RestAssured;
public class SampleTest {
    @Test
    public void test() {
        RestAssured.given()
                    .when().get("http://www.google.com")
                    .then().statusCode(200);
    }
}

• given-when-then 패턴을 이용한 코드를 작성
  • given : Test setup(테스트시 필요한 데이터, 및 파라미터를 셋팅)
  • when : Test action(Method type을 정의)
  • then : Test verification(Response Data를 검증)

REST Assured 사용

설정

• gradle

dependencies {
    ...
    testImplementation 'io.rest-assured:rest-assured:4.4.0'
    testImplementation 'io.rest-assured:json-schema-validator:4.4.0'
    ...
}

사용법

• Parameters

given().
       param("param1", "value1").
       param("param2", "value2").
when().
       get("/something");
       
// given().param("myList", "value1", "value2");

// List<String> values = new ArrayList<String>();
// values.add("value1");
// values.add("value2");
// given().param("myList", values)

REST Assured는 HTTP method에 기반하여 parameter type을 자동으로 결정, GET => query parameters / POST => form parameters

given().
       formParam("formParamName", "value1").
       queryParam("q0-998ueryParamName", "value2").
when().
       post("/something");

하지만, PUT, POST type에서 query parameter와 form parameter를 함께 사용할 때는 정확하게 명시해야한다.

• path parameter

post("/reserve/{hotelId}/{roomNumber}", "My Hotel", 23);

Response JSON의 Assersion 정의

1. then().assertThat()
2. Response Message에서 Assert 구문을 이용하는 방법

• Response Data 검증
  • equalTo : then().assertThat().body(equalTo("something"))
  • hasItems : then(). assertThat().body("lotto.winners.winnerId", hasItems(23, 54));
  • startsWith, endsWithPath : body("href", and(startsWith("http:/localhost:8080/"), endsWithPath("userId")));
  • time : when(). get("/"). then(). time(lessThan(2000L)); // Milliseconds
  • size : then().assertThat().body("size()", equalTo(10))
  • contain : then().assertThat(). body(containsString("some"))