Rework test harness into JS-first categories

Address review feedback by re-categorising the test suite so behaviour is
exercised through JS scripts in real game-test scenarios rather than trivial
Java unit tests:

- Wrapper coverage now drives raw JS values across typed boundaries
  (TestRuntime.as*), exercising the registered type wrappers end to end.
- Replace the kjs_reads getter fixtures with an entity-behaviour test: a
  script gives a spawned zombie a held item and moves a cow, verified Java-side.
- Add JS binding tests (incl. JsonIO/NBTIO file creation) and syntax tests.
- Assert exact event fire counts, and route Java assertions through AssertJ
  (GameAsserts) so failures carry actual-vs-expected messages.
- Trim builder fixtures to a few actually integrated into game tests.
- Drop the JUnit unittest package in favour of the JS-driven tests.

Author: hspragg-godaddy

build.gradle.kts

@@ -127,6 +127,7 @@ dependencies {
 		}
 	})
 
+	testImplementation("org.mockito:mockito-core:5.18.0")
 	testImplementation("org.assertj:assertj-core:3.27.3")
 }
 
@@ -157,8 +158,8 @@ val coverageRequested = gradle.startParameter.taskNames.any {
 	it.substringAfterLast(':').startsWith("coverage")
 }
 
-// The test source set holds both JUnit unit tests (...unittest, run by `test`) and the game-test
-// mod (...testmod, run by `runGametest`). Allow `test` to pass before any unit tests are present.
+// The test source set is driven by the game-test mod (...testmod, run by `runGametest`). JUnit
+// (`test`) is kept available as a last resort but currently holds no tests, so allow it to pass.
 tasks.named<Test>("test") {
 	failOnNoDiscoveredTests = false
 	if (coverageRequested) {

src/test/java/dev/latvian/mods/kubejs/testmod/GameAsserts.java

@@ -0,0 +1,40 @@
+package dev.latvian.mods.kubejs.testmod;
+
+import net.minecraft.gametest.framework.GameTestAssertException;
+import net.minecraft.gametest.framework.GameTestHelper;
+import net.minecraft.network.chat.Component;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/// Bridges AssertJ into the game-test framework so failures carry AssertJ's rich message (e.g. the
+/// actual vs expected count). A raw [AssertionError] is an [Error] the framework never catches - it
+/// crashes the server - so these rethrow any assertion failure as a [GameTestAssertException], which
+/// the framework reports, and which `thenWaitUntil` retries against, like any native game-test assert.
+public final class GameAsserts {
+	private GameAsserts() {
+	}
+
+	/// Runs {@code assertions}, converting any [AssertionError] into a [GameTestAssertException].
+	public static void assertj(GameTestHelper helper, Runnable assertions) {
+		try {
+			assertions.run();
+		} catch (AssertionError error) {
+			throw new GameTestAssertException(Component.literal(String.valueOf(error.getMessage())), (int) helper.getTick());
+		}
+	}
+
+	/// Asserts {@code id} was reported at least once.
+	public static void assertFired(GameTestHelper helper, String id) {
+		assertj(helper, () -> assertThat(TestRuntime.passed(id)).as("%s should have fired", id).isTrue());
+	}
+
+	/// Asserts {@code id} was reported exactly {@code expected} times, naming the actual count on mismatch.
+	public static void assertCount(GameTestHelper helper, String id, int expected) {
+		assertj(helper, () -> assertThat(TestRuntime.count(id)).as("%s fire count", id).isEqualTo(expected));
+	}
+
+	/// Surfaces any script-side assertion captured under {@code id} (see [TestRuntime#check]).
+	public static void assertVerified(GameTestHelper helper, String id) {
+		assertj(helper, () -> TestRuntime.verify(id));
+	}
+}

src/test/java/dev/latvian/mods/kubejs/testmod/TestRuntime.java

@@ -1,10 +1,20 @@
 package dev.latvian.mods.kubejs.testmod;
 
+import dev.latvian.mods.kubejs.color.KubeColor;
 import dev.latvian.mods.kubejs.entity.KubeEntityEvent;
 import dev.latvian.mods.kubejs.level.LevelBlock;
 import dev.latvian.mods.kubejs.testmod.assertion.KubeEntityEventAssert;
 import dev.latvian.mods.kubejs.testmod.assertion.LevelBlockAssert;
+import dev.latvian.mods.kubejs.util.Tristate;
 import dev.latvian.mods.rhino.Undefined;
+import net.minecraft.core.BlockPos;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.network.chat.MutableComponent;
+import net.minecraft.resources.Identifier;
+import net.minecraft.util.valueproviders.IntProvider;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.material.MapColor;
+import net.minecraft.world.phys.Vec3;
 import org.assertj.core.api.AbstractBooleanAssert;
 import org.assertj.core.api.AbstractDoubleAssert;
 import org.assertj.core.api.AbstractStringAssert;
@@ -13,9 +23,12 @@
 import org.assertj.core.api.ObjectAssert;
 import org.jspecify.annotations.Nullable;
 
+import java.time.Duration;
 import java.util.Map;
 import java.util.Set;
+import java.util.UUID;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.regex.Pattern;
 
 /// Bound into scripts as {@code TestRuntime} so a script can report a passing condition back to
 /// the game test that drives it, e.g. {@code TestRuntime.pass('block.break.dirt')}.
@@ -62,18 +75,34 @@ public static boolean passedStartup(String id) {
 		return STARTUP.contains(id);
 	}
 
-	/// Marks {@code id} reached and runs the script's assertions, capturing any [AssertionError] they
-	/// throw so it survives the event dispatcher (which otherwise swallows handler exceptions).
+	/// Marks {@code id} reached and runs the script's assertions, capturing any failure they throw so
+	/// it survives to [#verify]. Catches [Throwable] (not just [AssertionError]) because a failure at
+	/// script-load time would otherwise abort loading, and Rhino can surface an assertion wrapped in
+	/// its own exception type - [#asAssertionError] unwraps it back to the underlying [AssertionError].
 	public static void check(String id, Runnable assertions) {
 		pass(id);
 
 		try {
 			assertions.run();
-		} catch (AssertionError error) {
-			FAILURES.put(id, error);
+		} catch (Throwable error) {
+			FAILURES.put(id, asAssertionError(error));
 		}
 	}
 
+	private static AssertionError asAssertionError(Throwable error) {
+		for (var current = error; current != null; current = current.getCause()) {
+			if (current instanceof AssertionError assertionError) {
+				return assertionError;
+			}
+
+			if (current.getCause() == current) {
+				break;
+			}
+		}
+
+		return new AssertionError(error.toString(), error);
+	}
+
 	/// Re-throws any assertion failure captured under {@code id}, so the game test fails on its own
 	/// thread with AssertJ's message instead of merely timing out.
 	public static void verify(String id) {
@@ -119,4 +148,60 @@ public static <T> IterableAssert<T> assertThat(Iterable<? extends T> actual) {
 	public static ObjectAssert<Object> assertThat(@Nullable Object actual) {
 		return Assertions.assertThat(actual);
 	}
+
+	/// Boundaries for the JS-driven wrapper tests. Each declares a wrapped Java type, so passing a raw
+	/// JS value invokes the registered type wrapper and returns the coerced object for the script to
+	/// assert on - exercising the JS->Java conversion end to end, not a static `wrap` call.
+
+	public static Vec3 asVec3(Vec3 value) {
+		return value;
+	}
+
+	public static BlockPos asBlockPos(BlockPos value) {
+		return value;
+	}
+
+	public static ItemStack asItemStack(ItemStack value) {
+		return value;
+	}
+
+	public static MutableComponent asComponent(MutableComponent value) {
+		return value;
+	}
+
+	public static CompoundTag asCompoundTag(CompoundTag value) {
+		return value;
+	}
+
+	public static KubeColor asColor(KubeColor value) {
+		return value;
+	}
+
+	public static Identifier asId(Identifier value) {
+		return value;
+	}
+
+	public static UUID asUUID(UUID value) {
+		return value;
+	}
+
+	public static Tristate asTristate(Tristate value) {
+		return value;
+	}
+
+	public static Duration asDuration(Duration value) {
+		return value;
+	}
+
+	public static Pattern asPattern(Pattern value) {
+		return value;
+	}
+
+	public static IntProvider asIntProvider(IntProvider value) {
+		return value;
+	}
+
+	public static MapColor asMapColor(MapColor value) {
+		return value;
+	}
 }

src/test/java/dev/latvian/mods/kubejs/testmod/binding/BindingTests.java

@@ -0,0 +1,50 @@
+package dev.latvian.mods.kubejs.testmod.binding;
+
+import net.neoforged.testframework.DynamicTest;
+import net.neoforged.testframework.annotation.ForEachTest;
+import net.neoforged.testframework.annotation.TestHolder;
+import net.neoforged.testframework.gametest.EmptyTemplate;
+import net.neoforged.testframework.gametest.GameTest;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import static dev.latvian.mods.kubejs.testmod.GameAsserts.assertFired;
+import static dev.latvian.mods.kubejs.testmod.GameAsserts.assertVerified;
+import static dev.latvian.mods.kubejs.testmod.GameAsserts.assertj;
+import static org.assertj.core.api.Assertions.assertThat;
+
+/// Category 3. Verifies that script bindings are reachable and work (`binding_checks.js`), including
+/// that the file-writing bindings actually create files on disk.
+@ForEachTest(groups = "kubejs.binding")
+public class BindingTests {
+	@GameTest
+	@EmptyTemplate
+	@TestHolder(value = "binding_reachable", description = "ID/Text bindings are reachable from JS and behave as expected")
+	static void bindingReachable(final DynamicTest test) {
+		test.onGameTest(helper -> {
+			assertFired(helper, "binding.id");
+			assertVerified(helper, "binding.id");
+			assertFired(helper, "binding.text");
+			assertVerified(helper, "binding.text");
+			helper.succeed();
+		});
+	}
+
+	@GameTest
+	@EmptyTemplate
+	@TestHolder(value = "binding_file_io", description = "JsonIO/NBTIO bindings write files that exist on disk afterwards")
+	static void bindingFileIo(final DynamicTest test) {
+		test.onGameTest(helper -> {
+			assertFired(helper, "binding.jsonio");
+			assertVerified(helper, "binding.jsonio");
+			assertj(helper, () -> assertThat(Files.isRegularFile(Path.of("kubejs/test_binding.json"))).as("JsonIO should have created the json file").isTrue());
+
+			assertFired(helper, "binding.nbtio");
+			assertVerified(helper, "binding.nbtio");
+			assertj(helper, () -> assertThat(Files.isRegularFile(Path.of("kubejs/test_binding.nbt"))).as("NBTIO should have created the nbt file").isTrue());
+
+			helper.succeed();
+		});
+	}
+}