Comparer les révisions
1
Révisions
main
...
test/autotests
| Auteur | SHA1 | Date | ||
|---|---|---|---|---|
| ||||
|
|
59c51360d2 | |||
Aucun fichier ne correspond à votre recherche
@@ -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 <dossier>
|
||||
# Entrée : <dossier>/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 <dossier contenant src.tgz>"; 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 '<testsuite [^>]*>' "$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 '<failure' "$x" 2>/dev/null | head -30; done | head -120
|
||||
@@ -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<String> evenementsEcoutes(Class<?> c) {
|
||||
List<String> 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));
|
||||
}
|
||||
}
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur