Implicit assert statement in Groovy

Question

Given I have JUnit tests written in Groovy:

class AssertTests {

    @Test
    void "explicit assert statement"() {
        def value = 42
        assert value == 100
    }

    @Test
    void "no assert statement"() {
        def value = 42
        value == 100
    }

}

When I execute them, explicit assert statement test fails as expected thanks to assert statement.

no assert statement test passes and I would expect it to fail in a similar way how it's done when I use http://spockframework.org

How can I achieve implicit assert behavior for tests written in plain Groovy?

Answer 1

The answer is simple - you can't. Spock uses AST transformations to grab the code written in the then: part and transform it into the code that makes an equivalent of assertion (not the exact assert.)

To illustrate this, here is your test written in Spock:

import spock.lang.Specification

class TestSpec extends Specification {

    def "should fail"() {
        when:
        def value = 42

        then:
        assert value == 100
    }
}

And here is what its bytecode decompiled back to Java looks like:

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
import groovy.lang.GroovyObject;
import org.codehaus.groovy.runtime.ScriptBytecodeAdapter;
import org.codehaus.groovy.runtime.callsite.CallSite;
import org.spockframework.runtime.ErrorCollector;
import org.spockframework.runtime.SpockRuntime;
import org.spockframework.runtime.ValueRecorder;
import org.spockframework.runtime.model.BlockKind;
import org.spockframework.runtime.model.BlockMetadata;
import org.spockframework.runtime.model.FeatureMetadata;
import org.spockframework.runtime.model.SpecMetadata;
import spock.lang.Specification;

@SpecMetadata(
    filename = "TestSpec.groovy",
    line = 5
)
public class TestSpec extends Specification implements GroovyObject {
    public TestSpec() {
        CallSite[] var1 = $getCallSiteArray();
        super();
    }

    @FeatureMetadata(
        line = 7,
        name = "should fail",
        ordinal = 0,
        blocks = {@BlockMetadata(
    kind = BlockKind.WHEN,
    texts = {}
), @BlockMetadata(
    kind = BlockKind.THEN,
    texts = {}
)},
        parameterNames = {}
    )
    public void $spock_feature_0_0() {
        CallSite[] var1 = $getCallSiteArray();
        ErrorCollector $spock_errorCollector = (ErrorCollector)ScriptBytecodeAdapter.castToType(var1[0].callConstructor(ErrorCollector.class, false), ErrorCollector.class);
        ValueRecorder $spock_valueRecorder = (ValueRecorder)ScriptBytecodeAdapter.castToType(var1[1].callConstructor(ValueRecorder.class), ValueRecorder.class);

        Object var10000;
        try {
            Object value = 42;

            try {
                SpockRuntime.verifyCondition($spock_errorCollector, $spock_valueRecorder.reset(), "value == 100", Integer.valueOf(12), Integer.valueOf(16), (Object)null, $spock_valueRecorder.record($spock_valueRecorder.startRecordingValue(Integer.valueOf(2)), ScriptBytecodeAdapter.compareEqual($spock_valueRecorder.record($spock_valueRecorder.startRecordingValue(Integer.valueOf(0)), value), $spock_valueRecorder.record($spock_valueRecorder.startRecordingValue(Integer.valueOf(1)), 100))));
                var10000 = null;
            } catch (Throwable var14) {
                SpockRuntime.conditionFailedWithException($spock_errorCollector, $spock_valueRecorder, "value == 100", Integer.valueOf(12), Integer.valueOf(16), (Object)null, var14);
                var10000 = null;
            } finally {
                ;
            }

            var1[2].call(var1[3].call(this.getSpecificationContext()));
        } finally {
            $spock_errorCollector.validateCollectedErrors();
            var10000 = null;
        }

    }
}

If you look at the SpockRuntime class, you will find that verifyCondition method checks if the condition found in the then: or and: block evaluates to true:

public static void verifyCondition(@Nullable ErrorCollector errorCollector, @Nullable ValueRecorder recorder,
    @Nullable String text, int line, int column, @Nullable Object message, @Nullable Object condition) {
  if (!GroovyRuntimeUtil.isTruthy(condition)) {
    final ConditionNotSatisfiedError conditionNotSatisfiedError = new ConditionNotSatisfiedError(
      new Condition(getValues(recorder), text, TextPosition.create(line, column), messageToString(message), null, null));
    errorCollector.collectOrThrow(conditionNotSatisfiedError);
  }
}

You can't avoid explicit assert in JUnit tests. You can hide them in some helper method, but you still need to call them. Keep in mind, that JUnit runner requires that the test method returns void, so you can't capture the result of a test method. (Replace void with def, and you will see that JUnit does not run your test.)

If you want to explore the world of compile-time metaprogramming in Groovy, you could experiment with writing your own AST transformations. Maybe there is a way to find boolean expression(s) and inject assert in front of it, but I can't guarantee you that it will work. If you look for an out-of-the-box solution for implicit asserts in Groovy JUnit tests, there is no such one.