Tests not found by JUnit5 after compilation

[lostiniceland]

I am currently writing a Groovy plugin for the Mill build tool. So far it is looking good, sources get compiled and JUnit5 tests are runnable (by Mill and by IDE).

Only the compiled Spock classes refuse to be picked up by JUnit. The generated class files are locking good, IntelliJ recognizes the file as a Testable file, but when running JUnit it claims "no tests were found".

I even have the JUnit vintage runner in my classpath, without success. When I compare the decompiled bytecode, I can see that a Junit5 test uses the @Test annotation which is missing in the compiled Spock bytcode.

Sample:

class Test extends Specification {

    void "hello failing test"(){
        expect:
        true == false
    }
}

get compiled to

import groovy.lang.GroovyObject;
import groovy.lang.MetaClass;
import groovy.transform.Generated;
import groovy.transform.Internal;
import java.beans.Transient;
import org.codehaus.groovy.runtime.ScriptBytecodeAdapter;
import spock.lang.Specification;

public class Test extends Specification implements GroovyObject {
    @Generated
    public Test() {
        MetaClass var1 = this.$getStaticMetaClass();
        this.metaClass = var1;
    }

    public void hello_failing_test/* $FF was: hello failing test*/() {
        ScriptBytecodeAdapter.compareEqual(true, false);
    }

    @Generated
    @Internal
    @Transient
    public MetaClass getMetaClass() {
        MetaClass var10000 = this.metaClass;
        if (var10000 != null) {
            return var10000;
        } else {
            this.metaClass = this.$getStaticMetaClass();
            return this.metaClass;
        }
    }

    @Generated
    @Internal
    public void setMetaClass(MetaClass var1) {
        this.metaClass = var1;
    }
}

Whats the current status with the JUnit5 support? According to the docs, it seems the junit-vintage is no longer needed and spock-junit4 dependency seems also only necessary when still using JUnit4.
Do I need to pass some special compiler arguments?

[Vampire]

I even have the JUnit vintage runner in my classpath, without success.

That would only be relevant if you write Spock 1.x tests as those were JUnit 4 based and thus need the Vintage engine.
Spock 2+ is an own JUnit 5 platform engine.

When I compare the decompiled bytecode, I can see that a Junit5 test uses the @test annotation which is missing in the compiled Spock bytcode.

You confuse JUnit 5 Platform with JUnit 5 Jupiter engine.
The @Test annotation is a JUnit 5 Jupiter annotation that is used for JUnit 5 Jupiter tests.
JUnit 5 Jupiter is "just" a JUnit 5 Platform engine like any other JUnit 5 Platform engine.
So JUnit 5 Jupiter is more like a sibling of JUnit 5 Vintage engine (which runs JUnit 4 tests) and Spock (which runs Spock tests).

Spock brings its own JUnit 5 Platform engine, so if the Spock tests are not found, searching for differences to Jupiter tests is not really helpful.
Maybe you configured to only run Jupiter tests or something like that.

[Vampire]

From a quick look it seems Mill seems to have support for kotest which also is yet another JUnit 5 Platform engine.
So you might be able to have a look at how that is working to find out how to use Spock with it.

[lostiniceland]

Thats what I am actually doing...ripping of the current Kotlin module in Mill to get Groovy working :-).

There is some magic in how how the classes are picked up and my understanding was that I only need to support JUnit5. Thanks for your clarification that Spock ships its own Platform Engine.

Is there a certain engine class in the Spock artifact I need to dynamically load?

[lostiniceland]

Interestingly for Kotlin not much is done. An added dependency to a kotest-runner-junitX is added which ships a service-loader for the TestEngine. The same is already present in spock-core.

[lostiniceland]

I was able to resolve the issue. The problem was that I compiled the sources with the wrong classloader.
After using the GroovyClassloader the test were recognized.

...
    val parentCl: ClassLoader = this.getClass.getClassLoader
    val gcl = new GroovyClassLoader(parentCl, config)
    val unit = new CompilationUnit(config, null, gcl)
...

I am wondering why the compilation succeeded thought before.

[Vampire]

You probably did not have Spock in the compilation classpath and so the AST transformations that Spock is doing were not done.
Nevertheless the files are valid Groovy syntax, so they do compile, but are not Spock specs as the AST transformations are missing then.