Add game and junit tests to AP

.github/workflows/build-and-test.yaml

@@ -10,4 +10,6 @@ on:
 
 jobs:
   build-and-test:
-    uses: IntelligenceModding/actions/.github/workflows/build-and-test.yaml@master
+    uses: IntelligenceModding/actions/.github/workflows/build-and-test.yaml@master
+  run-gametests:
+    uses: IntelligenceModding/actions/.github/workflows/run-gametests.yaml@master

.gitignore

@@ -21,12 +21,12 @@ build
 eclipse
 run
 server
+/.jqwik-database
 
 # Files from Forge MDK
 forge*changelog.txt
 
 #github
-
 1.17
 .env
 

build.gradle

@@ -7,7 +7,7 @@ plugins {
     id 'net.darkhax.curseforgegradle' version '1.1.16'
     id 'org.jetbrains.changelog' version '1.2.1'
     id "com.modrinth.minotaur" version "2.+"
-    id "org.jetbrains.kotlin.jvm" version "1.6.10"
+    id "org.jetbrains.kotlin.jvm" version "${kotlin_version}"
     id 'net.minecraftforge.gradle' version '[6.0.18,6.2)'
     id 'org.parchmentmc.librarian.forgegradle' version '1.+'
     id 'org.spongepowered.mixin' version '0.7.+'
@@ -56,7 +56,23 @@ sourceSets {
     main.resources {
         srcDir 'src/generated/resources'
     }
-    testMod {}
+    testMod {
+        java.srcDir 'src/testMod/java'
+        kotlin.srcDir 'src/testMod/kotlin'
+        resources.srcDir 'src/testMod/resources'
+        compileClasspath += main.compileClasspath + test.compileClasspath
+        runtimeClasspath += main.runtimeClasspath + test.runtimeClasspath
+    }
+    testFixtures {
+        java.srcDir 'src/testFixtures/java'
+        kotlin.srcDir 'src/testFixtures/kotlin'
+        resources.srcDir 'src/testFixtures/resources'
+    }
+}
+
+java.registerFeature("testFixtures") {
+    usingSourceSet(sourceSets.testFixtures)
+    disablePublication()
 }
 
 minecraft {
@@ -66,7 +82,13 @@ minecraft {
     accessTransformer file('src/main/resources/META-INF/accesstransformer.cfg')
     accessTransformer file('src/testMod/resources/META-INF/accesstransformer.cfg')
 
+
     runs {
+        all {
+            lazyToken('minecraft_classpath') {
+                configurations.library.copyRecursive().resolve().collect { it.absolutePath }.join(File.pathSeparator)
+            }
+        }
         client {
             workingDirectory project.file('run')
 
@@ -126,38 +148,69 @@ minecraft {
             }
         }
 
-        testClient {
+        gameTestClient {
             workingDirectory project.file('test-files/client')
             parent runs.client
 
+            def oldClasspath = lazyTokens["minecraft_classpath"]
+            lazyToken("minecraft_classpath") {
+                // Add all files in testMinecraftLibrary to the classpath.
+                def allFiles = new HashSet<String>();
+
+                def minecraftClasspath = oldClasspath?.get()
+                if (minecraftClasspath != null && !minecraftClasspath.isEmpty()) allFiles.addAll(minecraftClasspath.split(File.pathSeparatorChar))
+
+                for (file in configurations["testMinecraftLibrary"]) allFiles.add(file.absolutePath)
+
+                println("New classpath $allFiles")
+                allFiles.join(File.pathSeparator)
+            }
+
+            property 'forge.logging.markers', 'REGISTRIES'
+            property 'forge.logging.console.level', 'debug'
+            property 'forge.enabledGameTestNamespaces', 'advancedperipherals,advancedperipheralstest'
+            property 'advancedperipheralstest.sources', file("src/testMod/resources/data/advancedperipheralstest").absolutePath
+
+            args "--mixin.config=advancedperipheralstest.mixins.json"
+
             mods {
-                aptest {
+                advancedperipheralstest {
                     source sourceSets.testMod
+                    source sourceSets.testFixtures
                 }
             }
+        }
 
-            lazyToken('minecraft_classpath') {
-                (configurations.implementationExtra.copyRecursive().resolve())
-                        .collect { it.absolutePath }
-                        .join(File.pathSeparator)
+        gameTestServer {
+            def oldClasspath = lazyTokens["minecraft_classpath"]
+            lazyToken("minecraft_classpath") {
+                // Add all files in testMinecraftLibrary to the classpath.
+                def allFiles = new HashSet<String>();
+
+                def minecraftClasspath = oldClasspath?.get()
+                if (minecraftClasspath != null && !minecraftClasspath.isEmpty()) allFiles.addAll(minecraftClasspath.split(File.pathSeparatorChar))
+
+                for (file in configurations["testMinecraftLibrary"]) allFiles.add(file.absolutePath)
+
+                println("New classpath $allFiles")
+                allFiles.join(File.pathSeparator)
             }
-        }
 
-        testServer {
             workingDirectory project.file('test-files/server')
+            property 'forge.logging.markers', 'REGISTRIES'
+            property 'forge.logging.console.level', 'debug'
+            property 'forge.enabledGameTestNamespaces', 'advancedperipherals,advancedperipheralstest'
+            property 'advancedperipheralstest.sources', file("src/testMod/resources/data/advancedperipheralstest").absolutePath
+
+            args "--mixin.config=advancedperipheralstest.mixins.json"
             parent runs.server
 
             mods {
-                aptest {
+                advancedperipheralstest {
                     source sourceSets.testMod
+                    source sourceSets.testFixtures
                 }
             }
-
-            lazyToken('minecraft_classpath') {
-                (configurations.implementationExtra.copyRecursive().resolve())
-                        .collect { it.absolutePath }
-                        .join(File.pathSeparator)
-            }
         }
     }
 }
@@ -247,9 +300,27 @@ repositories {
 }
 
 configurations {
+    minecraftLibrary { extendsFrom(minecraftEmbed) }
+
+    testMinecraftLibrary {
+        canBeResolved = true
+        canBeConsumed = false
+        // Prevent ending up with multiple versions of libraries on the classpath.
+        shouldResolveConsistentlyWith(minecraftLibrary)
+    }
+
+    library
+    implementation.extendsFrom library
     implementationExtra
+    testImplementation.extendsFrom(implementation)
     testModImplementation.extendsFrom(implementation)
     testModImplementation.extendsFrom(testImplementation)
+    testFixturesImplementation.extendsFrom(implementation)
+    testFixturesImplementation.extendsFrom(testImplementation)
+}
+
+processTestModResources {
+    duplicatesStrategy = 'exclude'
 }
 
 dependencies {
@@ -260,6 +331,7 @@ dependencies {
     compileOnly "org.jetbrains:annotations:${jb_annotations}"
     minecraft "net.minecraftforge:forge:${minecraft_version}-${forge_version}"
     implementation fg.deobf("org.squiddev:cc-tweaked-${minecraft_version}:${cc_version}")
+    implementation fg.deobf("org.squiddev:cc-tweaked-${minecraft_version}:${cc_version}:api")
     // Minimal requirements end
 
     // Extended requirements
@@ -295,7 +367,7 @@ dependencies {
     compileOnly fg.deobf("curse.maven:ae-additions-493962:${ae2additions_version}")
     //runtimeOnly fg.deobf("curse.maven:ae-additions-493962:${ae2additions_version}")
 
-    implementation fg.deobf("thedarkcolour:kotlinforforge:${kotlinforforge_version}")
+    runtimeOnly fg.deobf("thedarkcolour:kotlinforforge:${kotlinforforge_version}")
 
     // Botania
     compileOnly fg.deobf("vazkii.botania:Botania:${botania_version}")
@@ -323,9 +395,6 @@ dependencies {
     compileOnly fg.deobf("com.simibubi.create:create-${minecraft_version}:${create_version}:all")
     runtimeOnly fg.deobf("com.simibubi.create:create-${minecraft_version}:${create_version}:all")
 
-    //Removed until fully ported
-    //testImplementation fg.deobf("site.siredvin.ttoolkit:ttoolkit-${minecraft_version}:${ttoolkit_version}")
-
     //Powah
     compileOnly fg.deobf("curse.maven:powah-633483:${powah_version}")
     runtimeOnly fg.deobf("curse.maven:powah-633483:${powah_version}")
@@ -337,12 +406,17 @@ dependencies {
 
     testImplementation "org.junit.jupiter:junit-jupiter-api:${junit_version}"
     testImplementation "org.junit.jupiter:junit-jupiter-params:${junit_version}"
+    testImplementation "org.junit.jupiter:junit-jupiter-engine:${junit_version}"
+    testImplementation "net.jqwik:jqwik:${jqwikVersion}"
+    testImplementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:${kotlin_coroutines_version}"
     testImplementation "org.hamcrest:hamcrest:${hamcrest_version}"
-    testImplementation "org.jetbrains.kotlin:kotlin-reflect:${kotlin_version}"
-    testImplementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:${kotlinx_coroutines_version}"
     testModImplementation sourceSets.main.output
+    testModImplementation sourceSets.testFixtures.output
+
+    testMinecraftLibrary("org.junit.jupiter:junit-jupiter-api:${junit_version}")
+    testMinecraftLibrary("org.junit.jupiter:junit-jupiter-params:${junit_version}")
+    testMinecraftLibrary("org.hamcrest:hamcrest:${hamcrest_version}")
 
-    testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:${junit_version}"
     // Testing stuff
     // JEI
     implementation fg.deobf("mezz.jei:jei-${jei_version}")
@@ -370,6 +444,11 @@ changelog {
 
 compileTestModJava {
     dependsOn(compileJava)
+    dependsOn(compileKotlin)
+    dependsOn(compileTestJava)
+    dependsOn(compileTestKotlin)
+    dependsOn(compileTestFixturesJava)
+    dependsOn(compileTestFixturesKotlin)
 }
 
 task setupServer(type: Copy) {
@@ -383,28 +462,12 @@ task setupServer(type: Copy) {
     into "test-files/server"
 }
 
-["Client", "Server"].forEach { name ->
-    tasks.register("test$name", JavaExec.class).configure {
-        it.group('In-game tests')
-        it.description("Runs tests on a temporary Minecraft instance.")
-        it.dependsOn(setupServer, "prepareRunTest$name", "cleanTest$name", 'compileTestModJava')
-
-        JavaExec exec = tasks.getByName("runTest$name")
-        exec.copyTo(it)
-        it.setClasspath(exec.getClasspath())
-        it.mainClass = exec.mainClass
-        it.setArgs(exec.getArgs())
-
-        it.systemProperty('forge.logging.console.level', 'debug')
-        it.systemProperty('ttoolkit.run', 'true')
-    }
-}
-
 test {
     useJUnitPlatform()
     testLogging {
         events "skipped", "failed"
     }
+    finalizedBy('runGameTestServer')
 }
 
 afterEvaluate {

config/checkstyle/checkstyle.xml

@@ -22,7 +22,7 @@
 
         <!-- Blocks -->
         <module name="EmptyBlock">
-            <property name="tokens" value="LITERAL_WHILE,LITERAL_TRY,LITERAL_CATCH,LITERAL_FINALLY,LITERAL_DO,LITERAL_IF,LITERAL_ELSE,INSTANCE_INIT,STATIC_INIT,LITERAL_SWITCH,LITERAL_SYNCHRONIZED,LITERAL_CASE,LITERAL_DEFAULT,ARRAY_INIT"/>
+            <property name="tokens" value="LITERAL_WHILE,LITERAL_TRY,LITERAL_FINALLY,LITERAL_DO,LITERAL_IF,LITERAL_ELSE,INSTANCE_INIT,STATIC_INIT,LITERAL_SWITCH,LITERAL_SYNCHRONIZED,LITERAL_CASE,LITERAL_DEFAULT,ARRAY_INIT"/>
         </module>
         <module name="EmptyCatchBlock">
             <property name="exceptionVariableName" value="ignored" />
@@ -93,12 +93,12 @@
         <module name="LocalFinalVariableName" />
         <module name="LocalVariableName" />
         <module name="MemberName" />
-        <module name="MethodName" />
         <module name="MethodTypeParameterName">
             <property name="format" value="[A-Z ]+"/>
         </module>
         <module name="PackageName">
-            <property name="format" value="^de\.srendi\.advancedperipherals(\.[a-z][a-z0-9]*)*" />
+            <property name="format" value="(?:(dan200\.computercraft)|(de\.srendi\.advancedperipherals))(\.[a-z][a-z0-9]*)*" />
+            <!-- For the game tests -->
         </module>
         <module name="ParameterName" />
         <module name="StaticVariableName">

docs/CREATING_TESTS.MD

@@ -0,0 +1,72 @@
+## Creating Game Tests
+
+Since [#562](https://github.com/IntelligenceModding/AdvancedPeripherals/pull/562), Advanced Peripherals has a testing framework that allows us to write tests for our peripherals.
+The testing framework is copied from [ComputerCraft](https://github.com/cc-tweaked/CC-Tweaked) and adapted to Advanced Peripherals.
+
+### First things first.
+
+To write a test, you need to have a test world. But this needs to be done in the testing environment.
+To run the testing environment, run the gradle task `runTestClient`. This will start a new instance of Minecraft with the testing environment.
+That includes the ability to run tests, import and export tests using the `/cctest` and the `/test` command.
+
+After the tests are created, you can use the gradle task `runTestServer` to start the game test server which then runs all the test.
+To test a single test, you can also use `/test run <test_name>` in the testing environment.
+
+### Building your test structure
+
+Tests should have a base plate made out of andesite.
+Every test needs one computer and the peripheral you want to test. For example the environment detector.
+
+![assets/img.png](assets/img.png)
+
+Now you need to set a label to the computer, so it can run the lua test script.
+`label set <test_type>.<test_name>`
+For example, peripheraltest as the test type. The test type is the name of the `@GameTestHolder` class. PeripheralTest.kt for this type.
+`environment` would be our test name. So the label would be `peripheraltest.environment`.
+
+The computer needs the id 0 so it can load the default startup.lua and the tests scripts from the resources folder.
+
+Now to save your test, get a structure block, place it in the lower right corner of the test structure and set the mode to save.
+Use the command `/give @p minecraft:structure_block` to get a structure block.
+
+Set the size for your test and the structure name. The structure name is your test name with the minecraft namespace. `minecraft:peripheraltest.environment` in our case.
+
+![assets/img_1.png](assets/img_1.png)
+
+Click on done to save the content of the structure block and then on SAVE to save the structure.
+We now have our test structure saved as a .nbt file in the world folder. To export it as a snbt file, use the command `/cctest export`
+to export the file to the `src/testMod/resources/data/advancedperipherals/structures` folder, so it can be used by the game test server later.
+
+### Writing the test
+
+To write a test, you need to create a new class in the `src/testMod/kotlin/advancedperipherals/test` package or use one of the existing classes.
+The class should be annotated with `@GameTestHolder`.
+The class should have a function annotated with `@GameTest` that will be executed by the game test server later.
+The function needs to have the parameter `GameTestContext` that will be used to interact with the game world.
+
+A simple game test would look like this. You can see that the context can be used to interact with the world.
+You can then use one of the helper functions to interact with the computer. For example, `thenComputerOk()` to check if the script on the computer was executed without any fails.
+```kt
+    @GameTest
+    fun environment(context: GameTestHelper) = context.sequence {
+        context.level.setWeatherParameters(6000, 0, false, false);
+        thenComputerOk();
+    }
+```
+
+Of course, you need a lua script to interact with the peripheral. 
+The script should be placed in the `src/testMod/resources/data/advancedperipheralstest/computer/tests` folder and should be named after the test name.
+`peripheraltest.environment.lua` in our case.
+
+```lua
+detector = peripheral.find("environmentDetector")
+test.eq(detector ~= nil, true, "Peripheral not found")
+
+isRaining = detector.isRaining()
+test.eq(false,isRaining, "It should not rain")
+```
+
+Last but not least, import the script to the computer. You need to do that when you're currently in the test world, and you want to write the script in your IDE.
+Luckily, the test framework provides a command for that.
+`/cctest import` imports the scripts from the resources folder to the world folder.
+You can then find the script in the computer's folder using `ls tests/`.

gradle.properties

@@ -5,7 +5,7 @@ org.gradle.logging.level=info
 # Minecraft related
 mod_id=advancedperipherals
 minecraft_version=1.19.2
-forge_version=43.3.8
+forge_version=43.3.13
 loader_version=43
 mod_version=0.7.36r
 release_type=release
@@ -14,11 +14,12 @@ mappings_version=2022.11.27-1.19.2
 jb_annotations=21.0.1
 
 # Test dependencies
-junit_version=5.7.2
+junit_version=5.10.2
 hamcrest_version=2.2
-kotlin_version=1.8.0
-kotlinx_coroutines_version=1.6.0-RC3
 ttoolkit_version=0.1.3
+jqwikVersion=1.8.4
+kotlin_version=1.9.23
+kotlin_coroutines_version=1.8.0
 
 # Mod dependencies
 cc_version=1.101.3