Spock Test Framework 정리

JUnit 5 을 좀 더 세세하게 공부해볼까 하다 새로운 언어와 프레임워크를 사용해보고 싶어서 Spock Framework 를 공부하게 되었다.

Spock 는 Java, Groovy 애플리케이션을 위한 테스트 프레임워크다. BDD(Behaviour-Driven Development) 프레임워크라고도 한다. Groovy 언어로 작성할 수 있고, 아름답고 표현력이 뛰어나다고 소개하고 있다(ㅎㅎ). JUnit Runner 덕분에 대부분의 IDE, 빌드 툴, CI 서버에서 구동시킬 수 있다고 한다.

짧게 일주일정도 Spock 를 좀 써보고 느낀 점은 확실히 JUnit 보다 더 쉽고 명시적인 느낌이 있었다. 예를 들어 JUnit 을 쓸 때 테스트 메서드에 주석으로 given, when, then 이라고 작성했는데, Spock 에서는 각각을 블록이라고 하고 given: when: 이렇게 블록을 넣어줘야 동작한다. 좀 더 명시적으로 알아볼 수 있어서 좋았다. 또 JUnit 은 같은 메서드 이름이 여러 패키지에 존재해서 원하는 것을 사용하려면 외워서 사용했어야 했는데, Spock 는 All In One 스러운 느낌이 있었다. 그리고 Spock 의 에러 메세지는 보고 깜짝 놀랐다! 보면 알리라. 더 쓰다 보면 장단점을 느끼겠지만 첫인상은 굿굿이다.

Gradle 의존성 설정

plugins {
    id 'java'
    id 'groovy'
}

apply plugin: 'groovy'

group 'me.ohhhmycode'
version '1.0-SNAPSHOT'

repositories {
    mavenCentral()
}

dependencies {
    testCompile group: 'junit', name: 'junit', version: '4.12'
    testCompile group: 'org.spockframework', name: 'spock-core', version: '1.3-groovy-2.5'
}

 

- spock-core 의존성을 추가해준다. (mvnrepository.com)
- 개인적으로 Intellij 커뮤니티 버전을 사용 중인데, plugins 설정을 해줘야 Test 를 작성했을 때 'No tasks available' 가 뜨지 않고 테스트를 실행할 수 있었다.

의존성 설정과 플러그인 설정이 끝나면 /src/test/groovy 디렉토리를 생성하고 groovy 디렉토리에 테스트 클래스를 생성하도록 해야 한다.

---

import spock.lang.*

class MySpockTest extends Specification {

    def "첫번째 테스트 메소드"() {
        given:
        def x = 5;
        def y = 10;

        when:
        def sum = x + y;

        then:
        sum == 15;
    }

}

 

첫 번째 테스트 클래스를 작성해봤다. Specification 라는 클래스를 상속받고 있는 것이 보이는데 spock 테스트 클래스는 spock.lang 패키지의 Specification 을 상속받아야 한다. Specification 클래스에는 테스트를 작성하는데 필요한 중요한 것들이 대부분 있다.

아래부터는 문서 요약과 코드 예제로 훑어보면 될 것 같다.

Specifications

Spock 에서는 테스트를 작성하는 것을 Specification 을 작성한다고 하는데, Specifications 는 애플리케이션의 어떤 기능(feature)에 대해 예상되는 동작들을 작성한 것이라고 생각하면 될 것 같다. 그래서 Spock는 에서 테스트 메서드를 Feature Method 라고 한다.

위에서 말한 것처럼 Specification 클래스에 테스트를 작성하는데 필요한 대부분의 것이 있다. 그리고 Specification 에는 Sputnik 라는 JUnit Runner 가 있는데, Sputnik 로 Java 개발 툴들이나 빌드 툴에서 Spock 를 실행할 수 있는 것이라고 한다.

Fields

import spock.lang.*

class MySpockTest extends Specification {

    static def classStore = new HashSet();
    def myClass = new MyClass();

    def "필드 테스트 1"() {
        when:
        classStore.add(myClass);

        then:
        classStore.size() == 1
        println myClass // spocktest.MyClass@4a35cdc8
    }

    def "필드 테스트 2"() {
        when:
        classStore.add(myClass)

        then:
        classStore.size() == 2
        println myClass // spocktest.MyClass@6915ed51
    }

}

위 테스트는 통과한다. (Feature Method 가 순차적으로 위에서 아래로 실행되는 것 같다(?) 확인해봐야지..)

classStore, myClass 가 선언되어 있는 영역을 Instance Fields 라고 부르는데 테스트에서 사용하는 객체들을 선언하고 초기화하면 된다. (setup() 메서드에서 하는 것과 동일) 알아둬야 할 것은 인스턴스 필드에서 선언하고 초기화한 객체들은 각각의 Feature Method 에서 공유되지 않는다. 메서드는 항상 새로운 객체를 사용하기 때문에 각각의 테스트는 매번 분리된 환경에서 테스트를 수행할 수 있다.

객체를 모든 Feature Method 에서 공유해 사용하고 싶은 경우 @Shared 어노테이션을 붙이면 된다. (@setupSpec() 메서드에서 하는 것과 동일) 아래 메서드를 보자.

import spock.lang.*

class MySpockTest extends Specification {

    static def classStore = new HashSet();
    @Shared def myClass = new MyClass();

    def "필드 테스트 1"() {
        when:
        classStore.add(myClass);

        then:
        classStore.size() == 1
        println myClass // spocktest.MyClass@217f3ce1
    }

    def "필드 테스트 2"() {
        when:
        classStore.add(myClass)

        then:
        classStore.size() == 1
        println myClass // spocktest.MyClass@217f3ce1
    }

}

 

classStore 처럼 static 변수를 사용해 각 Feature Method 에서 공유할 수 있다. 다만 static 변수는 정말 상수를 사용할 때만 사용하고 그게 아니면 @Shared 어노테이션을 사용하는 것을 권장하고 있다. 위에서 classStore 도 사실 @Shared 어노테이션을 붙여서 사용하는 게 더 맞을 것 같다.

Fixture Methods

def setupSpec() {}    // 첫번째 feature method 실행 전에 한번 실행
def setup() {}        // 모든 feature method 실행 전에 매번 실행
def cleanup() {}      // 모든 feature method 실행 후에 매번 실행
def cleanupSpec() {}  // 마지막 feature method 실행 후에 한번 실행

 

Fixture Methods 는 테스트 환경을 세팅하거나 정리하는 역할을 한다. 필수는 아니므로 선택적으로 하면 된다. 

import spock.lang.*

class MySpockTest extends Specification {

    @Shared def sharedObj;
    def obj;

    def setupSpec() {
        sharedObj = new MyClass()
    }

    def setup() {
        obj = new MyClass()
    }
    
    // feature methods..
}

setupSpec() 에서 초기화하는 변수들은 @Shared 어노테이션을 붙이든가, static 변수이어야 한다. 
아래는 Fixture Methods 들이 실행되는 순서이다.

1. super.setupSpec
2. sub.setupSpec
3. super.setup
4. sub.setup
5. feature method
6. sub.cleanup
7. super.cleanup
8. sub.cleanupSpec
9. super.cleanupSpec

Feature Methods

import spock.lang.*

class MySpockTest extends Specification {
    
    def "한글로 테스트 메서드 이름을 작성할 수 있다"() {
    }

}

가장 중요한 Feature Methods 이다. 위에서 말했듯, Feature Method 는 개발하는 프로그램이 Spec 대로 잘 동작하는지 테스트 메서드를 작성해 확인하는 것이다. 관례적으로 문자열 리터럴로 Feature Method 의 이름을 짓는다고 한다. JUnit 을 사용할 때보다 좀 더 명확하게 테스트 명을 지을 수 있을 것 같다.

Feature Method 는 4단계로 구성된다.

1. Set Fixture
2. 프로그램 기능 수행 (Stimulus)
3. 프로그램 기능 수행 후의 Response 확인 (Describe the response)
4. Clear Fixture

1, 4단계는 위에서 본 것처럼 선택적으로 하면 된다. 문서에 2, 3 단계는 Stimulus to the system.., Describe the response.. 라고 되어 있는데 나름대로 풀어써봤다..^^; stimulus, response 는 항상 존재해야하고, 한번 이상 나올 수 있다.

Block

Spock 은 위에서 말한 4단계를 실행하기 위해 내장된 기능이 있다. 이걸 Block 라고 한다. 

given, when, then, expect, cleanup, where 라고 하는 6개의 블록이 있다. 각 블록은 given:, when: 과 같은 라벨로 시작되고 다음 블록이 나올 때까지의 영역이 다 해당 블록의 영역이 된다.

메서드의 시작부터 첫 번째 블록이 나올 때까지의 영역은 given 블록이 된다. given 이 가장 먼저와야하고 given 은 생략할 수 있다. 하지만 명시적으로 given: 을 써주는게 좋지 않을까 싶다.

Feature Method 는 적어도 하나의 블록은 가지고 있어야 하고, 블록을 중첩할 수는 없다. 아래 그림을 보고 각 단계에 해당하는 Block을 확인할 수 있다. where 는 좀 특수한 역할을 가지고 있다고 한다.

출처: http://spockframework.org/spock/docs/1.3/images/Blocks2Phases.png

Given Block

import spock.lang.*

class MySpockTest extends Specification {

    def "더하기 테스트"() {
        given:
        def x = 10;
        def y = 20;
    }

}

Given 블록에서는 테스트에 필요한 객체나 환경을 준비하는 곳이다. Given 블록 앞에 다른 블록은 올 수 없고, Given: 라벨은 생략할 수 있다. given: 라벨 대신에 setup: 라벨을 사용해도 된다.

When, Then Block

import spock.lang.*

class MySpockTest extends Specification {

    def "더하기 테스트"() {
        given:
        def x = 10;
        def y = 20;

        when: // stimulus
        def sum = x + y

        then: // response
        sum == 30
    }

}

when, then 블록은 항상 같이 사용해야 하고, 여러번 사용할 수 있다. when 에서 테스트 실행하고 -> then 에서 확인한다 라고 생각하면 될 것 같다. when 블록에서는 테스트하려는 코드를 작성하거나, 임의로 뭐 필요한 코드를 작성할 수 있는 반면에, then은 조건 확인(Conditions), 예외 확인(Exception Conditions), 인터랙션(Interaction), 변수 정의에 해당하는 코드를 작성하도록 제한되어 있다.

조건 확인, Conditions

Conditions 에서는 boolean 표현식을 사용해서 조건확인(상태확인)을 한다. JUnit 의 assertions 라고 생각하면 될 것 같다. then 의 한줄한줄이 조건을 확인하는 assert 문이 된다. 

package spocktest

import spock.lang.*

class MySpockTest extends Specification {

    def "Stack 테스트"() {
        given:
        def stack = new Stack();
        def number = 10;

        when:
        stack.push(number)

        then: // boolean 표현식으로 작성
        !stack.empty()
        stack.size() == 1
        stack.peek() == number
    }

}

Condition 은 항상 1~5개 정도로 유지하는 것이 좋다고 한다. 그 이상이 되면 Condition 들이 정말 연관되어 있는지 확인해보고, 테스트 메서드를 구체적으로 더 나눌 수 있는지 봐야 한다.

조건이 맞지 않는 경우는 아래처럼 피드백을 준다. 개인적으로 피드백 메세지를 보고 많이 놀랐다;

package spocktest

import spock.lang.*

class MySpockTest extends Specification {
    def "Stack 테스트"() {
        given:
        def stack = new Stack();
        def number = 10;

        when:
        stack.push(number)

        then:
        !stack.empty()
        stack.size() == 2 // 틀린 조건
        stack.peek() == number;
    }
}

Condition not satisfied:

stack.size() == 2
|     |      |
[10]  1      false

	at spocktest.MySpockTest.Stack 테스트(MySpockTest.groovy:29)

stack 의 현재 사이즈도 확인해서 보여주다니... 👍

예외 확인, Exception Conditions

package spocktest

import spock.lang.*

class MySpockTest extends Specification {

    def "Stack Exception 테스트"() {
        given:
        def stack = new Stack();

        when:
        stack.pop()

        then:
        thrown(EmptyStackException)
        stack.empty()
    }

}

when 에서 예외를 발생시켜야 하는 경우 then 에서 thrown() 메서드를 사용해 확인할 수 있다. 거의 그냥 코드만 잠깐 읽으면 이해할 수 있도록 쉽게 되어 있는 것 같다. then 블록에서 이렇게 예외를 확인하는 조건은 한 번만 사용할 수 있다.

예외 객체를 받으려면 아래처럼 하면 된다. 둘 중에 선택해 사용하면 될 것 같지만, 두 번째 방법이 더 나은 것 같다.

when:
stack.pop()

then:
def e = thrown(EmptyStackException)
e.message == "error message"

when:
stack.pop()

then:
EmptyStackException e = thrown()
e.message == "error message"

두번째 방법으로 받으면 강타입으로 체크가 가능하고, IDE 에서 코드 자동 완성 지원도 더 잘 받을 수 있다. 그리고 좀 더 가독성이 좋은 코드인 것 같다. 

만약 발생하지 않아야 할 예외 체크도 해야 할 경우 notThrown() 메서드를 사용하면 된다.

then:
notThrown(NullPointerException)

 

Interations

인터랙션은 Mock 객체를 생성해 특정 메서드가 몇 번 호출되는지, 메소드의 반환 값을 Stubbing 할 수도 있다. 인터렉션에 대해서는 내용이 정말 많은 것 같다. 지금은 아래 예제만 보고 넘어가고 Interaction은 날 잡고 또 봐야할 것 같다.

then:
1 * subscriber.receive("hello") // 1번 호출
subscriber.receive(_) >> "ok" // receive(_) 이 호출된 경우 "ok" 반환
subscriber.receive(_) >> { throw new InternalError("ouch") } // receive(_) 이 호출된 경우 예외 발생

 

Expect Blocks

then 블록과 비교해서 Expect 블록은 조건 확인, 변수 정의만 할 수 있다는 점에서 좀 더 제한적이다. Expect 블록은 코드 동작 => 조건 확인이 하나의 표현식에서 확인하는 것이 더 자연스러울 때 사용하면 좋다. Math.max() 메소드가 예가 될 수 있겠다.

when:
def max = Math.max(1, 3)

then:
max == 3

expect:
Math.max(1, 3) == 3

 

Cleanup Blocks

given:
def file = new File("/some/path")
file.createNewFile()

// ...

cleanup:
file.delete()

cleanup 블록 뒤에는 where 블록만 올 수 있고, cleanup 블록은 반복될 수 없다. 위에 코드처럼 테스트에서 사용한 객체를 할당 해제하거나 삭제하는 등의 행동을 한다. 객체는 사실 Garbage Collector가 정리해주니까 cleanup 에서 특별히 신경을 쓰지 않(?)아도 괜찮지만, 파일 시스템이나 DB 커넥션, 네트워크 서비스 같은 것들은 잘 정리할 필요가 있다. 모든 feature 메서드에서 사용하는 자원일 경우는 cleanup() Fixture 메서드를 쓰면 된다.

Where Blocks

where 블록은 항상 가장 마지막에 오고, 반복될 수 없다. data-driven 테스트를 할 때 사용된다.

import spock.lang.*

class MySpockTest extends Specification {
    def "where 블록 사용하기"() {
        expect:
        Math.max(a, b) == c

        where:
        a << [5, 3]
        b << [1, 9]
        c << [5, 9]

    }
}

Math.max(5, 1) == 5
Math.max(3, 9) == 9 순서대로 이렇게 평가가 된 것이다. 아래처럼 data tables 을 만들어 작성할 수도 있다.

import spock.lang.*

class MySpockTest extends Specification {
    def "where 블록 사용하기"() {
        expect:
        Math.max(a, b) == c

        where:
        a | b | c
        5 | 1 | 5
        3 | 9 | 9
    }
}

값만 바꿔서 테스트하는 코드를 작성할 때 정말 편할 것 같다. Where 블록에서 할 수 있는 Data Driven 테스팅도 내용이 정말 많았다. 이것도 인터렉션과 더불어서 더 공부하면서 사용하면 좋을 것 같다.

마무리

이렇게 어떤 프레임워크에 대해서 공부할 때 항상 누군가의 블로그나 영상을 참고하며 공부했지 이렇게 써본 적이 처음이다. 생각보다 정말 많은 시간이 들어가고 영어를 읽고 적당한 한글 표현으로 바꾸는 것이 얼마나 어려운지 새삼 다시 깨닫는다. 공식 문서를 차분히 읽다 보니 다른 사람들의 블로그를 볼 때와 다르게 좀 더 꼼꼼하게 알게 되고, 블로그에 쓰다 보니 또 잘 정리가 되는 것이 있는 것 같다.

Spock 프레임워크는 JUnit 과 비교해서는 좀 더 쉽게 접근할 수 있고, 더 명시적인 테스트를 작성할 수 있는 것 같다. 블록도 그렇고 에러 메세지도 정말 친절하게 보여준다. 좀 더 쓰면서 공부하다보면 장단점도 더 알게되고 JUnit 과 더 많은 비교를 할 수 있을 것 같다.

Spock 로 Spring 도 얼른 테스트를 해보고 싶다! 

 

 

References

spockframework.org/spock/docs/1.3/spock_primer.html
spockframework.org/spock/docs/1.3/interaction_based_testing.html
d2.naver.com/helloworld/568425