Spock 测试中未返回存根 object 方法值

Question

I am new to the Spock framework and writing a test case in which I am trying to Mock a class called QueryDatabase

public class QueryDatabase {

    public BigInteger countRecords(Instant start, Instant end) {

        Flux<CountRecord> countValue = query("select * from users");
        Optional<Object> value = Optional.ofNullable(countValue.blockFirst()).map(CountRecord::getValue);
        BigInteger count = value.filter(BigInteger.class::isInstance)
                    .map(BigInteger.class::cast).orElse(BigInteger.valueOf(0));

        return count
    }
    
    public Flux<CountRecord> query(String query) {
    
    }
}

but the below test case which is to check the value returned by countRecords(Instant, Instant) always gives 0, so that means the value returned in the when section

recordCount.query(_) >> Flux.just(CountRecord.builder().value(new BigInteger(133)).build())

is not getting used, seems like recordCount.query(_) >> Flux.empty() also does not have any impact and it always returns the default BigInteger value 0

def "record count"() {

        given:
        def now = Instant.now()
        def last10Minutes = now.minus(10, ChronoUnit.MINUTES);
        def recordCount = Stub(QueryDatabase)

        when: "query returning empty flux"
        recordCount.query(_) >> Flux.empty()

        then:
        recordCount.countRecords(last10Minutes, now) == 0

        when: "query returning the count record"
        recordCount.query(_) >> Flux.just(CountRecord.builder().value(new BigInteger(133)).build())

        then:
        recordCount.countRecords(last10Minutes, now) == 133

 }

Am I doing anything wrong here?

Answer 1

There are several issues with your code.

1. You try to set up some stubbing in the when block
2. You perform your action in the then block
3. You try to redefine stubs

See Combining Mocking and Stubbing on how this works.

def "record count"() {    
        given:
        def now = Instant.now()
        def last10Minutes = now.minus(10, ChronoUnit.MINUTES);
        def recordCount = Spy(QueryDatabase)

        when: "query returning empty flux"
        def result = recordCount.countRecords(last10Minutes, now)

        then:            
        1 * recordCount.query(_) >> Flux.empty()
        result == 0

        when: "query returning the count record"
        def 2ndResult = recordCount.countRecords(last10Minutes, now) == 133

        then:            
        1 * recordCount.query(_) >> Flux.just(CountRecord.builder().value(new BigInteger(133)).build())
        2ndResult == 133    
 }

Alternatively, you could split it up into a data driven feature

def "record count"(BigInteger result, Flux input) {    
        given:
        def now = Instant.now()
        def last10Minutes = now.minus(10, ChronoUnit.MINUTES);
        def recordCount = Spy(QueryDatabase)
        recordCount.query(_) >> input

        expect:          
        recordCount.countRecords(last10Minutes, now) == result

        where: 
        result | input
        0      | Flux.empty()
        133    | Flux.just(CountRecord.builder().value(new BigInteger(133)).build())
 }

Normally, you'd order the parameters the other way around, but since the fluxes are so verbose I find this better readable.

-- EDIT:

I missed that you are trying to stub that same object that you are testing, this can only be done with partial mocking and often indicates, that the code should be refactored. So replace Mock / Stub with Spy for partial mocking.

Answer 2

What about this way when you override the query method to return an expected Flux . In this case I would recommend to have 2 tests:

def "record count when empty Flux"() {
        given:
        def now = Instant.now()
        def last10Minutes = now.minus(10, ChronoUnit.MINUTES);
        def recordCount = new QueryDatabase() {
          @Overriden
          public Flux<CountRecord> query(String query) {
            Flux.empty()
          }
        }

        expect:
        recordCount.countRecords(last10Minutes, now) == 0
 }

def "record count when non empty Flux"() {
        given:
        def now = Instant.now()
        def last10Minutes = now.minus(10, ChronoUnit.MINUTES);
        def recordCount = new QueryDatabase() {
          @Overriden
          public Flux<CountRecord> query(String query) {
            Flux.just(CountRecord.builder().value(new BigInteger(133)).build())
          }
        }

        expect:
        recordCount.countRecords(last10Minutes, now) == 133
 }