From 59c51360d27c4bbbc5bb74508091dbd5e060f49e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Th=C3=A9o=20Gastinel?= <264859180+gastinelt@users.noreply.github.com> Date: Fri, 16 Oct 2026 05:57:25 +0200 Subject: [PATCH] Autotests adverses GastinelClaims (FAILLE_/FAUX_POSITIF_) et script conteneur Co-Authored-By: Claude Opus 5.5 --- autotests-conteneur.sh | 40 +++ .../gastinelclaims/AutotestClaimsTest.java | 247 ++++++++++++++++++ 2 files changed, 287 insertions(+) create mode 100644 autotests-conteneur.sh create mode 100644 src/test/java/com/gastinelclaims/AutotestClaimsTest.java diff --git a/autotests-conteneur.sh b/autotests-conteneur.sh new file mode 100644 index 0000000..b5816b0 --- /dev/null +++ b/autotests-conteneur.sh @@ -0,0 +1,40 @@ +#!/bin/sh +# Autotests (16/10/2026) : compile et lance les tests dans un conteneur JDK 21 jetable (rien installé sur l'hôte). +# Usage (sur la machine de build) : sh autotests-conteneur.sh +# Entrée : /src.tgz (copie du worktree test/autotests, sans .git ni build). +# Ne touche à aucun serveur Minecraft ni à son conteneur. +set -e +D="$1" +[ -n "$D" ] && [ -f "$D/src.tgz" ] || { echo "usage : $0 "; exit 2; } +cd "$D" +rm -rf src-build +mkdir src-build +tar xzf src.tgz -C src-build +cd src-build +sed -i 's/\r$//' gradlew +mkdir -p "$HOME/.cache/gastinelclaims-gradle" +set +e +nice -n 10 docker run --rm --memory 4g --cpus 4 \ + -u "$(id -u):$(id -g)" \ + -e GRADLE_USER_HOME=/gradle-home \ + -v "$HOME/.cache/gastinelclaims-gradle:/gradle-home" \ + -v "$(pwd):/src" -w /src \ + eclipse-temurin:21-jdk \ + sh ./gradlew --no-daemon clean test > "$D/build.log" 2>&1 +CODE=$? +set -e +echo "code de sortie gradle : $CODE" +grep -E "FAILED|BUILD|error:|tests completed" "$D/build.log" | head -40 +echo "--- totaux (XML JUnit) ---" +T=0; F=0; E=0; S=0 +for x in build/test-results/test/*.xml; do + [ -f "$x" ] || continue + l=$(grep -o ']*>' "$x" | head -1) + t=$(echo "$l" | sed -n 's/.* tests="\([0-9]*\)".*/\1/p'); f=$(echo "$l" | sed -n 's/.* failures="\([0-9]*\)".*/\1/p') + e=$(echo "$l" | sed -n 's/.* errors="\([0-9]*\)".*/\1/p'); s=$(echo "$l" | sed -n 's/.* skipped="\([0-9]*\)".*/\1/p') + T=$((T+t)); F=$((F+f)); E=$((E+e)); S=$((S+s)) + echo "$(basename "$x") tests=$t echecs=$f erreurs=$e ignores=$s" +done +echo "TOTAL tests=$T echecs=$F erreurs=$E ignores=$S" +echo "--- echecs detailles ---" +for x in build/test-results/test/*.xml; do grep -A8 '/dev/null | head -30; done | head -120 diff --git a/src/test/java/com/gastinelclaims/AutotestClaimsTest.java b/src/test/java/com/gastinelclaims/AutotestClaimsTest.java new file mode 100644 index 0000000..078adde --- /dev/null +++ b/src/test/java/com/gastinelclaims/AutotestClaimsTest.java @@ -0,0 +1,247 @@ +package com.gastinelclaims; + +import com.gastinelclaims.core.ChunkKey; +import com.gastinelclaims.core.ClaimRegistry; +import net.neoforged.bus.api.SubscribeEvent; +import org.junit.jupiter.api.Test; + +import java.io.IOException; +import java.lang.reflect.Method; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.List; +import java.util.UUID; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Autotests adverses de GastinelClaims (16/10/2026). + * + * Convention (comme GastinelGarde, branche test/cas-limites) : un test FAILLE_… (contournement) ou + * FAUX_POSITIF_… (joueur honnête puni) PASSE TANT QUE LE DÉFAUT EXISTE. Le jour du correctif, il échoue : + * il faut alors inverser son assertion (il devient un test de non-régression). + * + * Trois sortes de preuves : + * - logique : appel direct de ClaimRegistry (code de production) ; + * - réflexion : liste des méthodes @SubscribeEvent réellement présentes dans les classes du mod + * (prouve l'ABSENCE d'un gestionnaire d'événement) ; + * - hiérarchie de classes Minecraft (chargées sans initialisation). + * Rien ici n'est testé en jeu. + */ +class AutotestClaimsTest { + + private static final String OW = "minecraft:overworld"; + + /** Types d'événements écoutés par une classe du mod (paramètre des méthodes @SubscribeEvent). */ + private static List evenementsEcoutes(Class c) { + List out = new ArrayList<>(); + for (Method m : c.getDeclaredMethods()) { + if (m.isAnnotationPresent(SubscribeEvent.class) && m.getParameterCount() == 1) { + out.add(m.getParameterTypes()[0].getName()); + } + } + return out; + } + + private static boolean ecoute(Class c, String fragmentDeNom) { + return evenementsEcoutes(c).stream().anyMatch(n -> n.contains(fragmentDeNom)); + } + + /** Dossier du projet : le test tourne parfois dans build/minecraft-junit (moddev unitTest). */ + private static Path racine() { + Path p = Path.of("").toAbsolutePath(); + while (p != null && !Files.isDirectory(p.resolve("src/main/java"))) p = p.getParent(); + assertNotNull(p, "dossier du projet introuvable depuis " + Path.of("").toAbsolutePath()); + return p; + } + + private static String source(String chemin) throws IOException { + return Files.readString(racine().resolve("src/main/java/com/gastinelclaims/" + chemin), StandardCharsets.UTF_8); + } + + private static Class classeMc(String nom) throws ClassNotFoundException { + return Class.forName(nom, false, AutotestClaimsTest.class.getClassLoader()); + } + + // --- Témoin : la réflexion voit bien les gestionnaires existants --- + + @Test + void temoin_laReflexionVoitLesGestionnairesExistants() { + assertTrue(ecoute(ProtectionEvents.class, "BlockEvent$BreakEvent")); + assertTrue(ecoute(ProtectionEvents.class, "ExplosionEvent$Detonate")); + // ZoneEvents (spawn) gère bien pistons, liquides et mobs : la comparaison avec les claims est juste. + assertTrue(ecoute(ZoneEvents.class, "PistonEvent$Pre")); + assertTrue(ecoute(ZoneEvents.class, "FluidPlaceBlockEvent")); + assertTrue(ecoute(ZoneEvents.class, "EntityMobGriefingEvent")); + } + + // --- C1 : pistons --- + + @Test + void FAILLE_C1_aucunControleDePistonPourLesClaims() { + // Un piston (collant) posé HORS du claim, contre sa bordure, pousse ou tire des blocs du claim + // (et pousse des rails, de la lave figée, du TNT… dedans). Seule la zone de spawn est couverte. + for (Class c : List.of(ProtectionEvents.class, ClaimCommands.class)) { + assertFalse(ecoute(c, "PistonEvent"), c.getSimpleName() + " écoute PistonEvent : faille corrigée ?"); + } + } + + // --- C2 / C3 : liquides et feu --- + + @Test + void FAILLE_C2_liquidesVenusDeLExterieurEntrentDansLesClaims() throws IOException { + assertFalse(ecoute(ProtectionEvents.class, "FluidPlaceBlockEvent")); + String mixin = source("mixin/FlowingFluidMixin.java"); + assertTrue(mixin.contains("ZonesProtegees.protege"), "témoin : le mixin protège la zone de spawn"); + assertFalse(mixin.contains("ClaimsData") || mixin.contains("ClaimRegistry"), + "le mixin des liquides consulte les claims : faille corrigée ?"); + } + + @Test + void FAILLE_C3_leFeuAllumeDehorsSePropageEtBruleDansLesClaims() throws IOException { + String mixin = source("mixin/FireBlockMixin.java"); + assertTrue(mixin.contains("ZonesProtegees.protege")); + assertFalse(mixin.contains("ClaimsData") || mixin.contains("ClaimRegistry"), + "le mixin du feu consulte les claims : faille corrigée ?"); + } + + // --- C4 : projectiles --- + + @Test + void FAILLE_C4_projectilesNonControlesAnimauxCadresSupportsDArmure() { + // AttackEntityEvent ne couvre que le coup au corps à corps. Flèche, trident, boule de neige, + // potion jetable, canne à pêche : rien n'est vérifié pour les entités d'un claim. + for (String e : List.of("ProjectileImpactEvent", "LivingIncomingDamageEvent", "LivingDamageEvent", + "LivingAttackEvent")) { + assertFalse(ecoute(ProtectionEvents.class, e), e + " écouté : faille corrigée ?"); + } + } + + // --- C5 : mobs --- + + @Test + void FAILLE_C5_endermenEtMobsGriefentLesClaims() { + assertFalse(ecoute(ProtectionEvents.class, "EntityMobGriefingEvent")); + assertFalse(ecoute(ProtectionEvents.class, "LivingDestroyBlockEvent")); + } + + // --- C6 : FakePlayer (Create deployer) dans le chunk visé --- + + @Test + void FAILLE_C6_machineDontLeFakePlayerEstDansLeChunkViseAgitCommeLeProprietaire() { + // Modèle de ProtectionEvents.allowed (branche FakePlayer) : acteur = propriétaire du chunk OÙ EST la + // machine. Si le FakePlayer se trouve dans le chunk visé (déployeur sur une contraption Create qui + // entre dans le claim, ou dont la position du FakePlayer est la case devant lui), l'acteur EST le + // propriétaire : tout est permis. Le calcul ci-dessous est celui du code de production. + ClaimRegistry r = new ClaimRegistry(); + UUID victime = UUID.randomUUID(); + ChunkKey claim = new ChunkKey(OW, 10, 10); + r.claim(victime, claim, 25); + + ChunkKey ouEstLaMachine = claim; // la machine est entrée dans le chunk + UUID acteur = r.ownerOf(ouEstLaMachine); + assertTrue(r.canAccess(acteur, claim, false), "la machine d'un inconnu agit comme la victime"); + + // Témoin : la même machine restée dehors (chunk libre) est refusée. + assertFalse(r.canAccess(r.ownerOf(new ChunkKey(OW, 11, 10)), claim, false)); + } + + // --- C7 : piétinement par les mobs --- + + @Test + void FAILLE_C7_seulsLesJoueursNePietinentPasLesCultures() throws IOException { + String s = source("ProtectionEvents.java"); + assertTrue(s.contains("onTrample(BlockEvent.FarmlandTrampleEvent event)")); + assertTrue(s.contains("if (event.getEntity() instanceof Player p"), + "un mob (ou un joueur sur un cheval/cochon) piétine librement : seul un Player est contrôlé"); + } + + // --- FP1 : entités « non hostiles » qui attaquent --- + + @Test + void FAUX_POSITIF_FP1_impossibleDeSeDefendreContreLoupGolemAbeilleOursDansUnClaim() throws Exception { + // isProtectedEntity(e) = !(e instanceof Enemy) && !(e instanceof Player). + // Ces mobs peuvent attaquer un joueur mais n'implémentent pas Enemy : dans le claim d'un autre, + // le joueur attaqué ne peut pas riposter (coup annulé). + String s = source("ProtectionEvents.java"); + assertTrue(s.contains("return !(e instanceof Enemy) && !(e instanceof Player);")); + Class enemy = classeMc("net.minecraft.world.entity.monster.Enemy"); + for (String n : List.of("net.minecraft.world.entity.animal.Wolf", "net.minecraft.world.entity.animal.IronGolem", + "net.minecraft.world.entity.animal.Bee", "net.minecraft.world.entity.animal.PolarBear", + "net.minecraft.world.entity.animal.horse.Llama", "net.minecraft.world.entity.animal.goat.Goat")) { + assertFalse(enemy.isAssignableFrom(classeMc(n)), n + " implémente Enemy"); + } + // Témoin : un zombie est bien Enemy (attaquable partout). + assertTrue(enemy.isAssignableFrom(classeMc("net.minecraft.world.entity.monster.Zombie"))); + } + + // --- FP2 : le propriétaire ne peut rien faire exploser chez lui --- + + @Test + void FAUX_POSITIF_FP2_explosionsAnnuleesMemeLanceesParLeProprietaire() throws IOException { + // onExplosion retire tout bloc d'un chunk claim, sans regarder qui a allumé la TNT. + String s = source("ProtectionEvents.java"); + assertTrue(s.contains("event.getAffectedBlocks().removeIf(pos -> r.ownerOf(ClaimsData.key(level, pos)) != null);")); + } + + // --- Réfutés (pas de faille) --- + + @Test + void honnete_amiUnilateral_lAmiDeAnAPasAccesAuxClaimsDeB() { + ClaimRegistry r = new ClaimRegistry(); + UUID a = UUID.randomUUID(), b = UUID.randomUUID(), c = UUID.randomUUID(); + ChunkKey ka = new ChunkKey(OW, 0, 0), kb = new ChunkKey(OW, 1, 0); + r.claim(a, ka, 25); + r.claim(b, kb, 25); + r.addFriend(a, b); // B est ami de A + r.addFriend(b, c); // C est ami de B + assertTrue(r.canAccess(b, ka, false)); + assertFalse(r.canAccess(a, kb, false), "l'amitié n'est pas réciproque"); + assertFalse(r.canAccess(c, ka, false), "l'amitié n'est pas transitive"); + } + + @Test + void honnete_claimUneDimensionNeProtegePasLAutre() { + ClaimRegistry r = new ClaimRegistry(); + UUID a = UUID.randomUUID(), b = UUID.randomUUID(); + r.claim(a, new ChunkKey(OW, 0, 0), 25); + assertTrue(r.canAccess(b, new ChunkKey("minecraft:the_nether", 0, 0), false)); + assertFalse(r.canAccess(b, new ChunkKey(OW, 0, 0), false)); + } + + @Test + void honnete_coordonneesNegativesBienRangeesDansLeChunk() { + // -1 doit être dans le chunk -1 (et non 0) : sinon un claim fuirait d'un bloc. + ChunkKey k = ChunkKey.ofBlock(OW, -1, -16); + assertEquals(-1, k.x()); + assertEquals(-1, k.z()); + assertEquals(0, ChunkKey.ofBlock(OW, 15, 0).x()); + assertEquals(1, ChunkKey.ofBlock(OW, 16, 0).x()); + } + + @Test + void honnete_limiteDeClaimsNonContournableParUnclaimReclaim() { + ClaimRegistry r = new ClaimRegistry(); + UUID a = UUID.randomUUID(); + for (int i = 0; i < 3; i++) assertEquals(ClaimRegistry.ClaimResult.OK, r.claim(a, new ChunkKey(OW, i, 0), 3)); + assertEquals(ClaimRegistry.ClaimResult.LIMIT_REACHED, r.claim(a, new ChunkKey(OW, 9, 0), 3)); + r.unclaim(a, new ChunkKey(OW, 0, 0)); + r.unclaim(a, new ChunkKey(OW, 0, 0)); // double unclaim : le compteur ne doit pas descendre deux fois + assertEquals(2, r.countOf(a)); + assertEquals(ClaimRegistry.ClaimResult.OK, r.claim(a, new ChunkKey(OW, 9, 0), 3)); + assertEquals(ClaimRegistry.ClaimResult.LIMIT_REACHED, r.claim(a, new ChunkKey(OW, 10, 0), 3)); + } + + @Test + void honnete_unInconnuNePeutPasUnclaimNiVolerUnChunk() { + ClaimRegistry r = new ClaimRegistry(); + UUID a = UUID.randomUUID(), b = UUID.randomUUID(); + ChunkKey k = new ChunkKey(OW, 3, 3); + r.claim(a, k, 25); + assertEquals(ClaimRegistry.UnclaimResult.NOT_OWNER, r.unclaim(b, k)); + assertEquals(ClaimRegistry.ClaimResult.CLAIMED_BY_OTHER, r.claim(b, k, 25)); + assertEquals(a, r.ownerOf(k)); + } +}