diff --git a/README.md b/README.md index a8315fb0..d22cab51 100644 --- a/README.md +++ b/README.md @@ -328,7 +328,7 @@ Research artifacts and reproducible probes are indexed by topic in [docs/researc - Java synthetic enum-switch holders and Kotlin callable references are classified separately from source anonymous objects. Library-inline implementation classes require verified compiler output, synthetic metadata and a verified enclosing declaration; their raw JVM identities remain significant. If provenance fails, graph analysis continues with raw identities and explicitly unverified diff observations, while the verdict remains FAIL and dependent obligations remain unproved. See [origin boundaries](docs/design.md#104-匿名类与图的稳定关联). - JDK declarations are resolved from the running JDK image, including `jdk.compiler`, without searching GraphFold’s application classpath. This resolves declarations only; it does not establish safe effects for arbitrary JDK calls. Frontend proof decisions consume structured completeness from the final folded graph and reconcile the method receipts delivered by the same `loadObserved` invocation. Missing bodies, failed observations and incomplete dispatch cannot become evidence of no effects. Application string literals are not method-completeness records. Selection uses Graphite’s parsed Cypher AST: certified direct CallSite-property predicates can tolerate unrelated native/dispatch gaps, while other query shapes conservatively require complete graph evidence. Incomplete body extraction still blocks; selecting only known targets of incomplete dispatch cannot broaden the fold. - Native Gradle and Maven plugins consume packaged outputs from their current build models. There is no standalone CLI or plain-source build adapter. Direct javac/kotlinc fixture compilers are test-only. Custom compiler plugins, generators, Kotlin Multiplatform, and dependency arrangements require separate validation. -- Build-system analysis reads application classes from final packaged applications. Gradle application JARs use their build-declared ordered dependency archives; explicitly selected JARs also include local manifest `Class-Path` entries. Compiler outputs supply source provenance only and never add classes missing from the package. Bytecode replaced during packaging stays replaced in the graph; it cannot inherit compiler provenance without verified byte identity. Multi-release JARs select one view using the actual build JDK recorded by the integration, independently for BASE and HEAD; the analyzer host JVM does not choose a version. Conflicting class definitions require explicit input evidence rather than inferred launcher behavior. Resources and service registrations come from packaged archives. +- Build-system analysis reads application classes from final packaged applications. Gradle application JARs use their build-declared ordered dependency archives; explicitly selected JARs also include local manifest `Class-Path` entries. Compiler outputs supply source provenance only and never add classes missing from the package. Bytecode replaced during packaging stays replaced in the graph; it cannot inherit compiler provenance without verified byte identity. Multi-release JARs select one view using the actual build JDK recorded by the integration, independently for BASE and HEAD; the analyzer host JVM does not choose a version. An integration’s ordered classpath or a complete packaged Spring Boot `BOOT-INF/classpath.idx` determines which definition enters the graph. Without order evidence, different definitions remain unresolved static input; an index is unnecessary for unambiguous archives. All packaged class bytes, annotations and resources remain in the change inventory, including definitions outside the effective graph. Resources and service registrations come from packaged archives. - Each selected archive defines a separate static analysis scope. Library-only Gradle builds use production JARs declared by `runtimeElements`; Maven uses each current module’s packaged artifact. Unrelated module outputs are never merged into an application. Reports qualify scenario names as `name [scope identity]` when multiple scopes are analyzed. Added and removed scopes are compared against empty inputs using their actual bytecode; scope membership is not itself a verdict. Plugins select final artifacts from their native models; engine input decoding normalizes archives and rejects unreadable inputs before graph analysis. Missing source mappings reduce attribution precision without preventing graph construction or folding. - Unknown external observation behavior does not block literal application-code comparison when declarations and method identities are retained without opaque normalization or method omission. Surviving method differences still fail control coverage. Missing application bodies, metadata changes, resource proofs and transformations requiring knowledge of an external observer retain their relevant diagnostics. - Effective dependency projections are reused within one analysis only when dependency content, input projection policy, relevant class definitions and application class copies agree. Inputs are hashed again on lookup, including directory resources. This avoids repeated validation and rewriting of shared libraries without synthesizing deployment scopes from library modules. diff --git a/engine/src/main/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/ArchiveInput.kt b/engine/src/main/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/ArchiveInput.kt index 6bfdb0ab..ec392481 100644 --- a/engine/src/main/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/ArchiveInput.kt +++ b/engine/src/main/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/ArchiveInput.kt @@ -3,7 +3,8 @@ package io.johnsonlee.graphfold.engine.inputs.archive import java.nio.file.Files import java.nio.file.Path import java.util.jar.JarFile -import java.util.jar.JarEntry +import java.util.zip.ZipEntry +import java.util.zip.ZipFile /** An explicitly selected archive; compiler outputs provide source evidence, never replacement graph bytes. */ data class ArchiveEntryInput( @@ -33,8 +34,8 @@ internal fun prepareArchiveInput( entry.copy(application = entry.application || selectedPrimary || input.ownsApplicationArchive(entry.artifact)) }) val expanded = springBootArchiveInput(selected, output.resolve("boot")) - ?: warArchiveInput(selected, output.resolve("war")) ?: selected - return prepareFlatArchiveInput(expanded, provenance, output, variantThreshold).copy(archiveInput = input) + ?: warArchiveInput(selected, output.resolve("war")) ?: ArchiveProjection(selected, StaticClassOrder.EXPLICIT_ORDER) + return prepareFlatArchiveInput(expanded.input, provenance, output, variantThreshold, expanded.classOrder).copy(archiveInput = input) } /** Membership is independent of source association; legacy producer records also establish project ownership. */ @@ -42,7 +43,7 @@ internal fun ArchiveInput.ownsApplicationArchive(artifact: Path): Boolean = (applicationArchives + producerArchives.keys).any { Files.isRegularFile(it) && Files.mismatch(it, artifact) == -1L } private fun prepareFlatArchiveInput( - input: ArchiveInput, provenance: InputProject, output: Path, variantThreshold: Int, + input: ArchiveInput, provenance: InputProject, output: Path, variantThreshold: Int, classOrder: StaticClassOrder, ): InputProject { checkInput(input.classpath.isNotEmpty(), "Input scope ${input.id} has no packaged classpath") val original = input.classpath.map { canonicalPackagedArchive(it.artifact) } @@ -52,7 +53,7 @@ private fun prepareFlatArchiveInput( val restored = original.mapIndexed { index, artifact -> selectedArchiveInventory(artifact, variantThreshold, output.resolve("inventory/$index.jar")) } - val ordinary = restored.mapIndexed { index, path -> + val ordinary = original.mapIndexed { index, path -> val archive = output.resolve("archives/$index.jar") if (input.classpath[index].inventoryOnly) { Files.createDirectories(archive.parent) @@ -60,17 +61,11 @@ private fun prepareFlatArchiveInput( archive } else normalizePackagedArchive(path, archive) } - // Identical definitions may deduplicate, but an application's copy must retain its application role. - // Different definitions still fail shared normalization regardless of this role-based processing order. - val classOrder = input.classpath.indices.sortedBy { if (input.classpath[it].application) 0 else 1 } - val normalized = normalizeDependencyInputs(classOrder.map(ordinary::get), output.resolve("effective"), - variantThreshold = variantThreshold) - val byIndex = classOrder.zip(normalized).toMap() - val effective = ordinary.indices.map(byIndex::getValue) + val effective = normalizeDependencyInputs(ordinary, output.resolve("effective"), + variantThreshold = variantThreshold, classOrder = classOrder) val classes = Files.createDirectories(output.resolve("classes")) - input.classpath.indices.filter { input.classpath[it].application }.forEach { index -> - copyPackagedClasses(effective[index], classes) - } + copyApplicationClasses(effective, input.classpath.indices.filter { input.classpath[it].application }.map(ordinary::get), + classes, variantThreshold) val dependencies = normalizeDependencyInputs(effective, output.resolve("dependencies"), variantThreshold = variantThreshold, applicationClasses = classes) val ownedOutputs = input.classpath.flatMap { it.producerOutputs }.map { it.toFile().canonicalFile.toPath() }.toSet() @@ -78,7 +73,7 @@ private fun prepareFlatArchiveInput( .mapValues { (_, groups) -> groups.flatten().map { it.toFile().canonicalFile.toPath() } .filter { it in ownedOutputs }.distinct() }.filterValues { it.isNotEmpty() } val resources = restored.mapIndexed { index, artifact -> - packagedResources(artifact, output.resolve("resources/$index")) + packagedResources(artifact, output.resolve("resources/$index"), original = artifact == original[index]) } val inventory = captureProductionInventory(classes, resources, restored, input.classpath.indices.filter { input.classpath[it].application }.map { restored[it] }) @@ -102,22 +97,12 @@ private fun canonicalCompilerClasspaths( contexts.singleOrNull().orEmpty() } -private fun copyPackagedClasses(archive: Path, output: Path) { - JarFile(archive.toFile()).use { jar -> - jar.entries().asSequence().filter { !it.isDirectory && it.name.endsWith(".class") }.forEach { entry -> - val target = output.resolve(entry.name).normalize() - checkInput(target.startsWith(output) && output.relativize(target).joinToString("/") == entry.name, - "Unsupported packaged class path: ${entry.name}") - Files.createDirectories(target.parent) - jar.getInputStream(entry).use { Files.copy(it, target) } - } - } -} - /** Preserve each artifact's effective resource entries separately; conflicting properties remain unproved. */ -private fun packagedResources(artifact: Path, output: Path): Path { +private fun packagedResources(artifact: Path, output: Path, original: Boolean): Path { Files.createDirectories(output) - JarFile(artifact.toFile()).use { jar -> + // The inventory projection preserves signature evidence, but only original bytes can be authenticated. + val archive = if (original) JarFile(artifact.toFile()) else ZipFile(artifact.toFile()) + archive.use { jar -> jar.stream().use { entries -> entries.filter { !it.isDirectory && !it.name.endsWith(".class") && !it.name.startsWith("META-INF/versions/") } .forEach { entry -> copyPackagedResource(jar, entry, output) } @@ -133,7 +118,7 @@ private fun ProductionInventory.withArchiveMetadata(input: ArchiveInput): Produc resourceIndependentEntries = resourceIndependentEntries + inputs) } -private fun copyPackagedResource(jar: JarFile, entry: JarEntry, output: Path) { +private fun copyPackagedResource(jar: ZipFile, entry: ZipEntry, output: Path) { val target = output.resolve(entry.name).normalize() checkInput(target.startsWith(output) && target != output && output.relativize(target).joinToString("/") == entry.name, "Unsupported packaged resource path: ${entry.name}") diff --git a/engine/src/main/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/ArchiveProjection.kt b/engine/src/main/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/ArchiveProjection.kt new file mode 100644 index 00000000..2fc811cc --- /dev/null +++ b/engine/src/main/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/ArchiveProjection.kt @@ -0,0 +1,6 @@ +package io.johnsonlee.graphfold.engine.inputs.archive + +/** Order evidence belongs to static input preparation, independently of application ownership. */ +internal enum class StaticClassOrder { UNAMBIGUOUS, EXPLICIT_ORDER } + +internal data class ArchiveProjection(val input: ArchiveInput, val classOrder: StaticClassOrder) diff --git a/engine/src/main/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/ArchiveVariants.kt b/engine/src/main/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/ArchiveVariants.kt index e3d4a5ca..d4a4ea11 100644 --- a/engine/src/main/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/ArchiveVariants.kt +++ b/engine/src/main/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/ArchiveVariants.kt @@ -24,7 +24,10 @@ internal fun archiveVariant(name: String): Pair? = VERSIONED_ENTRY. private val VERSIONED_ENTRY = Regex("""META-INF/versions/([1-9][0-9]*)/(.+)""") -/** Inventory and graphs see the same build-selected MR contents, including effective resource entries. */ +/** + * Inventory retains original metadata alongside build-selected contents. This is an evidence ZIP, not a signed JAR: + * consumers must use ZIP readers; graph normalization independently reads the original signed archive. + */ internal fun selectedArchiveInventory(archive: Path, javaVersion: Int, output: Path): Path = JarFile(archive.toFile()).use { jar -> val multiRelease = jar.manifest?.mainAttributes?.getValue(Attributes.Name.MULTI_RELEASE) @@ -43,3 +46,11 @@ internal fun selectedArchiveInventory(archive: Path, javaVersion: Int, output: P private fun copyArchiveEntry(jar: JarFile, entry: JarEntry, target: JarOutputStream) { jar.getInputStream(entry).use { it.copyTo(target) } } + +/** Signing blocks authenticate the original archive, never an analysis projection with rewritten entries. */ +internal fun archiveSignature(name: String): Boolean { + val normalized = name.uppercase(java.util.Locale.ROOT) + if (!normalized.startsWith("META-INF/")) return false + val file = normalized.removePrefix("META-INF/") + return '/' !in file && (file.startsWith("SIG-") || file.substringAfterLast('.') in setOf("SF", "RSA", "DSA", "EC")) +} diff --git a/engine/src/main/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/DependencyInputCache.kt b/engine/src/main/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/DependencyInputCache.kt index 3048d1ce..ad476160 100644 --- a/engine/src/main/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/DependencyInputCache.kt +++ b/engine/src/main/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/DependencyInputCache.kt @@ -8,14 +8,16 @@ import java.util.jar.JarFile /** Per-analysis reuse only: content, prior class definitions and application copies all participate in the key. */ internal class DependencyInputCache { private data class Input(val path: Path, val digest: String, val variant: Int) - private data class Key(val input: Input, val shadowed: Map, val application: Map) + private data class Key( + val input: Input, val shadowed: Map, val application: Map, val classOrder: StaticClassOrder, + ) private data class Projection(val path: Path, val introduced: Map) private val names = mutableMapOf>() private val projections = mutableMapOf() fun materialize( dependency: Path, variantThreshold: Int, application: Path?, selected: MutableMap, - produce: () -> Path, + classOrder: StaticClassOrder, produce: () -> Path, ): Path { val path = dependency.toAbsolutePath().normalize() val input = Input(path, digest(path), variantThreshold) @@ -25,7 +27,7 @@ internal class DependencyInputCache { root?.resolve(name)?.normalize()?.takeIf { it.startsWith(root) && Files.isRegularFile(it) } ?.let { name to digest(it) } }.toMap() - val key = Key(input, selected.filterKeys { it in classes }, copies) + val key = Key(input, selected.filterKeys { it in classes }, copies, classOrder) val projection = projections.getOrPut(key) { val before = selected.keys.toSet() Projection(produce(), selected.filterKeys { it !in before }) diff --git a/engine/src/main/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/DependencyInputs.kt b/engine/src/main/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/DependencyInputs.kt index 9986cdc2..56cb324d 100644 --- a/engine/src/main/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/DependencyInputs.kt +++ b/engine/src/main/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/DependencyInputs.kt @@ -18,13 +18,14 @@ import org.objectweb.asm.tree.ClassNode * Normalizes explicitly selected static classpaths without selecting bytecode by the analyzer JVM. * All bytecode consumers must receive these same paths; production inventories retain the original archives. * Multi-release alternatives are explicit variants. Validated module descriptors remain metadata, while service - * resources remain in the selected classpath. Different class definitions are ambiguous; independent scopes are never combined. + * resources remain in the selected classpath. Definitions follow explicit input order when supplied; independent scopes stay separate. */ internal fun normalizeDependencyInputs( dependencies: List, output: Path, variantThreshold: Int = 0, applicationClasses: Path? = null, cache: DependencyInputCache? = null, + classOrder: StaticClassOrder = StaticClassOrder.UNAMBIGUOUS, ): List { - val selection = StaticClassSelection(applicationClasses) + val selection = StaticClassSelection(applicationClasses, classOrder) return dependencies.mapIndexed { index, dependency -> checkInput(Files.exists(dependency), "Missing input dependency: $dependency") val target = output.resolve("dependency-$index.jar") @@ -33,7 +34,7 @@ internal fun normalizeDependencyInputs( else materializeArchive(dependency, target, selection, variantThreshold) } if (cache == null) produce() - else cache.materialize(dependency, variantThreshold, applicationClasses, selection.selected, produce) + else cache.materialize(dependency, variantThreshold, applicationClasses, selection.selected, classOrder, produce) } } @@ -56,7 +57,7 @@ private fun materializeArchive( if (!requiresArchiveProjection(archive, physical, entries.size, retained.size)) return@use dependency validateArchiveProjection(archive, dependency) writeInputArchive(target) { zip -> - retained.forEach { entry -> + retained.filterNot { archiveSignature(it.name) }.forEach { entry -> val bytes = contents(entry) writeEntry(zip, entry.name, if (entry.name == JarFile.MANIFEST_NAME) projectedManifest(bytes) else bytes) } @@ -96,7 +97,7 @@ private fun materializeDirectory( } if (retained.size == entries.size) return dependency writeInputArchive(target) { zip -> - retained.forEach { (name, file) -> + retained.filterKeys { !archiveSignature(it) }.forEach { (name, file) -> val bytes = Files.readAllBytes(file) writeEntry(zip, name, if (name == JarFile.MANIFEST_NAME) projectedManifest(bytes) else bytes) } @@ -104,8 +105,8 @@ private fun materializeDirectory( return target } -/** A static scope may contain identical copies, but never two different definitions of one class. */ -private class StaticClassSelection(applicationClasses: Path?) { +/** Different definitions require explicit classpath order; ownership never determines the selected bytes. */ +private class StaticClassSelection(applicationClasses: Path?, private val classOrder: StaticClassOrder) { private val application = applicationClasses?.toAbsolutePath()?.normalize() val selected = mutableMapOf() @@ -114,12 +115,14 @@ private class StaticClassSelection(applicationClasses: Path?) { val contents = bytes() val identity = MessageDigest.getInstance("SHA-256").digest(contents).joinToString("") { "%02x".format(it) } val previous = selected.putIfAbsent(name, identity) - checkInput(previous == null || previous == identity, "Ambiguous static class definition: $name") + checkInput(classOrder == StaticClassOrder.EXPLICIT_ORDER || previous == null || previous == identity, + "Ambiguous static class definition: $name") val file = application?.let { root -> root.resolve(name).normalize().takeIf { it.startsWith(root) && Files.isRegularFile(it) } } if (file != null) { - checkInput(Files.readAllBytes(file).contentEquals(contents), "Ambiguous application/dependency class definition: $name") + checkInput(classOrder == StaticClassOrder.EXPLICIT_ORDER || Files.readAllBytes(file).contentEquals(contents), + "Ambiguous application/dependency class definition: $name") } return previous == null && file == null } diff --git a/engine/src/main/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/PackagedClassOwnership.kt b/engine/src/main/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/PackagedClassOwnership.kt new file mode 100644 index 00000000..7b3b3337 --- /dev/null +++ b/engine/src/main/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/PackagedClassOwnership.kt @@ -0,0 +1,37 @@ +package io.johnsonlee.graphfold.engine.inputs.archive + +import java.nio.file.Files +import java.nio.file.Path +import java.security.MessageDigest +import java.util.HexFormat +import java.util.jar.JarFile + +/** Matching application copies retain ownership without changing the already selected classpath definition. */ +internal fun copyApplicationClasses(effective: List, applications: List, output: Path, variantThreshold: Int) { + val owned = mutableMapOf>() + applications.forEach { artifact -> visitPackagedClasses(artifact, variantThreshold) { name, bytes -> + owned.getOrPut(name) { mutableSetOf() }.add(classIdentity(bytes)) + } } + effective.forEach { artifact -> visitPackagedClasses(artifact, variantThreshold, owned.keys) { name, bytes -> + if (classIdentity(bytes) in owned.getValue(name)) { + val target = output.resolve(name).normalize() + checkInput(target.startsWith(output) && output.relativize(target).joinToString("/") == name, + "Unsupported packaged class path: $name") + Files.createDirectories(target.parent) + Files.write(target, bytes) + } + } } +} + +private fun visitPackagedClasses( + artifact: Path, variantThreshold: Int, names: Set? = null, visit: (String, ByteArray) -> Unit, +) { + JarFile(artifact.toFile()).use { jar -> + staticArchiveEntries(jar, variantThreshold).filterKeys { name -> + name.endsWith(".class") && (names == null || name in names) + }.forEach { (name, entry) -> visit(name, jar.getInputStream(entry).use { it.readBytes() }) } + } +} + +private fun classIdentity(bytes: ByteArray): String = + HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(bytes)) diff --git a/engine/src/main/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/PackagedManifestClasspath.kt b/engine/src/main/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/PackagedManifestClasspath.kt index 7d533a7a..b76e1b1c 100644 --- a/engine/src/main/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/PackagedManifestClasspath.kt +++ b/engine/src/main/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/PackagedManifestClasspath.kt @@ -49,7 +49,7 @@ internal fun normalizePackagedArchive(path: Path, output: Path): Path = JarFile( val encoded = manifest?.let { value -> ByteArrayOutputStream().also { value.write(it) }.toByteArray() } Files.createDirectories(output.parent) ZipOutputStream(Files.newOutputStream(output)).use { zip -> - retained.forEach { entry -> copyPackagedEntry(jar, zip, entry, encoded) } + retained.filterNot { archiveSignature(it.name) }.forEach { entry -> copyPackagedEntry(jar, zip, entry, encoded) } } output } diff --git a/engine/src/main/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/SpringBootArchiveInput.kt b/engine/src/main/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/SpringBootArchiveInput.kt index 18fb3fe4..3a52bae3 100644 --- a/engine/src/main/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/SpringBootArchiveInput.kt +++ b/engine/src/main/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/SpringBootArchiveInput.kt @@ -1,5 +1,7 @@ package io.johnsonlee.graphfold.engine.inputs.archive +import java.io.BufferedReader +import java.io.InputStreamReader import java.nio.file.Files import java.nio.file.Path import java.util.jar.JarEntry @@ -18,8 +20,8 @@ internal fun isSpringBootArchive(path: Path): Boolean = JarFile(path.toFile()).u } } -/** Project actual packaged class bytes and libraries in stable archive-name order. */ -internal fun springBootArchiveInput(input: ArchiveInput, output: Path): ArchiveInput? { +/** Project actual packaged classes and preserve the dependency order declared by a complete packaged index. */ +internal fun springBootArchiveInput(input: ArchiveInput, output: Path): ArchiveProjection? { val entry = input.classpath.singleOrNull() if (entry == null || !isSpringBootArchive(entry.artifact)) return null Files.createDirectories(output) @@ -30,7 +32,10 @@ internal fun springBootArchiveInput(input: ArchiveInput, output: Path): ArchiveI val rootEntries = entries.filterNot { it.name.startsWith(BOOT_CLASSES) || it.name.startsWith(BOOT_LIBRARIES) } val root = bootProjection(jar, rootEntries, "", output.resolve("loader.jar")) val classpath = mutableListOf(ArchiveEntryInput(root)) - val nestedEntries = entries.filter(::bootClasspathEntry).sortedBy { it.name }.toMutableList() + val packaged = entries.filter(::bootClasspathEntry) + val libraries = packaged.filter { it.name != BOOT_CLASSES } + val indexed = bootClasspathIndex(jar, libraries) + val nestedEntries = (packaged.filter { it.name == BOOT_CLASSES } + (indexed ?: libraries)).toMutableList() if (nestedEntries.none { it.name == BOOT_CLASSES } && entries.any { it.name.startsWith(BOOT_CLASSES) }) { nestedEntries.add(0, JarEntry(BOOT_CLASSES)) } @@ -46,11 +51,25 @@ internal fun springBootArchiveInput(input: ArchiveInput, output: Path): ArchiveI application = input.ownsApplicationArchive(path)) } } - input.copy(classpath = classpath + input.staticDependencies.map { ArchiveEntryInput(it) }, - archiveMetadata = input.archiveMetadata + mapOf("kind" to "spring-boot")) + ArchiveProjection(input.copy(classpath = classpath + input.staticDependencies.map { ArchiveEntryInput(it) }, + archiveMetadata = input.archiveMetadata + mapOf("kind" to "spring-boot")), + if (indexed == null) StaticClassOrder.UNAMBIGUOUS else StaticClassOrder.EXPLICIT_ORDER) } } +/** An absent or incomplete index leaves ordinary unambiguous archives analyzable. */ +private fun bootClasspathIndex(jar: JarFile, libraries: List): List? { + val index = jar.getJarEntry("BOOT-INF/classpath.idx") ?: return null + val lines = BufferedReader(InputStreamReader(jar.getInputStream(index), Charsets.UTF_8)) + .use { it.readLines() }.filter { it.isNotBlank() } + val names = lines.mapNotNull { BOOT_INDEX_ENTRY.matchEntire(it)?.groupValues?.get(1) } + val available = libraries.associateBy { it.name } + return if (names.size == lines.size && names.size == available.size && names.toSet() == available.keys) + names.map(available::getValue) else null +} + +private val BOOT_INDEX_ENTRY = Regex("""- "([^"]+)"""") + private fun bootClasspathEntry(entry: JarEntry): Boolean = entry.isDirectory && entry.name == BOOT_CLASSES || !entry.isDirectory && entry.name.startsWith(BOOT_LIBRARIES) && entry.name.endsWith(".jar") diff --git a/engine/src/main/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/WarArchiveInput.kt b/engine/src/main/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/WarArchiveInput.kt index 908dd158..41abae3e 100644 --- a/engine/src/main/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/WarArchiveInput.kt +++ b/engine/src/main/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/WarArchiveInput.kt @@ -4,7 +4,7 @@ import java.nio.file.Files import java.nio.file.Path /** Static WAR scope consists of packaged application classes/libraries and explicitly provided external types. */ -internal fun warArchiveInput(input: ArchiveInput, output: Path): ArchiveInput? { +internal fun warArchiveInput(input: ArchiveInput, output: Path): ArchiveProjection? { val wars = input.classpath.filter { it.artifact.fileName.toString().endsWith(".war", ignoreCase = true) } if (wars.isEmpty()) return null checkInput(wars.size == 1, "A WAR input must identify one WAR: ${input.id}") @@ -35,9 +35,9 @@ internal fun warArchiveInput(input: ArchiveInput, output: Path): ArchiveInput? { } val ordered = web + provided val resources = writeAnalysisArchive(output.resolve("web-resources.jar"), envelope) - return input.copy(classpath = ordered + ArchiveEntryInput(resources, inventoryOnly = true), + return ArchiveProjection(input.copy(classpath = ordered + ArchiveEntryInput(resources, inventoryOnly = true), archiveMetadata = input.archiveMetadata + mapOf("kind" to "war", - "webResources" to archiveContentIdentity(envelope))) + "webResources" to archiveContentIdentity(envelope))), StaticClassOrder.UNAMBIGUOUS) } private fun warLibrary(name: String): Boolean = name.startsWith("WEB-INF/lib/") && diff --git a/engine/src/test/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/ArchiveInputTest.kt b/engine/src/test/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/ArchiveInputTest.kt index f24d814d..1d482543 100644 --- a/engine/src/test/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/ArchiveInputTest.kt +++ b/engine/src/test/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/ArchiveInputTest.kt @@ -43,16 +43,15 @@ class ArchiveInputTest { @ParameterizedTest @ValueSource(booleans = [false, true]) - fun `different packaged definitions are rejected in either archive order`(externalFirst: Boolean) { + fun `explicit archive order selects different packaged definitions without ownership reordering`(externalFirst: Boolean) { val compiled = provenance() val external = archive("external.jar", mapOf("sample/Main.class" to bytecode("sample/Main", 7))) val app = archive("app.jar", mapOf("sample/Main.class" to bytecode("sample/Main", 1))) val entries = listOf(ArchiveEntryInput(app, listOf(compiled.classes)), ArchiveEntryInput(external)) - val failure = assertFailsWith { - prepareArchiveInput(ArchiveInput("app", if (externalFirst) entries.reversed() else entries), compiled, - temporary.resolve("prepared")) - } - assertTrue(failure.message.contains("Ambiguous static class definition")) + val result = prepareArchiveInput(ArchiveInput("app", if (externalFirst) entries.reversed() else entries), compiled, + temporary.resolve("prepared")) + assertContentEquals(bytecode("sample/Main", if (externalFirst) 7 else 1), + Files.readAllBytes(result.classes.resolve("sample/Main.class"))) } @ParameterizedTest diff --git a/engine/src/test/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/PackagedJvmLookupTest.kt b/engine/src/test/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/PackagedJvmLookupTest.kt index 3b3f7a8c..56cc69a1 100644 --- a/engine/src/test/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/PackagedJvmLookupTest.kt +++ b/engine/src/test/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/PackagedJvmLookupTest.kt @@ -11,7 +11,6 @@ import org.junit.jupiter.api.io.TempDir import kotlin.test.assertContentEquals import kotlin.test.assertEquals import kotlin.test.assertTrue -import kotlin.test.assertFailsWith class PackagedJvmLookupTest { @TempDir lateinit var temporary: Path @@ -46,7 +45,7 @@ class PackagedJvmLookupTest { } } - @Test fun `conflicting archive definitions cannot hide behind classpath order`() { + @Test fun `explicit archive order selects bytes while shadowed production definitions remain inventoried`() { val external = compile("external", mapOf("sample/Value.java" to value("external-first"))) val externalJar = archive("external.jar", classEntries(external)) val app = compile("app", mapOf("sample/Value.java" to value("application-later"), @@ -55,11 +54,11 @@ class PackagedJvmLookupTest { public class Main { public static void main(String[] a) { System.out.print(Value.text()); } } """.trimIndent())) val appJar = archive("app.jar", classEntries(app)) - val failure = assertFailsWith { - prepareArchiveInput(ArchiveInput("app", listOf(ArchiveEntryInput(externalJar), - ArchiveEntryInput(appJar, listOf(app)))), provenance(app), temporary.resolve("projection")) - } - assertTrue(failure.message.contains("Ambiguous static class definition")) + val result = prepareArchiveInput(ArchiveInput("app", listOf(ArchiveEntryInput(externalJar), + ArchiveEntryInput(appJar, listOf(app)))), provenance(app), temporary.resolve("projection")) + assertContentEquals(Files.readAllBytes(external.resolve("sample/Value.class")), + Files.readAllBytes(result.classes.resolve("sample/Value.class"))) + assertTrue("artifact/1/sample/Value.class" in result.production!!.nonClassEntries) } @Test fun `manifest dependencies resolve beside the physical archive target`() { diff --git a/engine/src/test/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/ShadowedProductionGoldenTest.kt b/engine/src/test/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/ShadowedProductionGoldenTest.kt new file mode 100644 index 00000000..578cc2ec --- /dev/null +++ b/engine/src/test/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/ShadowedProductionGoldenTest.kt @@ -0,0 +1,89 @@ +package io.johnsonlee.graphfold.engine.inputs.archive + +import io.johnsonlee.graphfold.engine.DiagnosticCode +import io.johnsonlee.graphfold.engine.EngineConfiguration +import io.johnsonlee.graphfold.engine.GraphFoldEngine +import io.johnsonlee.graphfold.engine.PreparedAnalysisRequest +import io.johnsonlee.graphfold.engine.Verdict +import io.johnsonlee.graphfold.engine.git.changedFile +import io.johnsonlee.graphfold.engine.inputs.PreparedRevision +import java.nio.file.Files +import java.nio.file.Path +import javax.tools.ToolProvider +import org.junit.jupiter.api.io.TempDir +import org.junit.jupiter.params.ParameterizedTest +import org.junit.jupiter.params.provider.ValueSource +import org.objectweb.asm.ClassWriter +import org.objectweb.asm.Opcodes +import kotlin.test.assertContentEquals +import kotlin.test.assertEquals +import kotlin.test.assertTrue + +/** Effective graph selection cannot discharge changes to another packaged production definition. */ +class ShadowedProductionGoldenTest { + @TempDir lateinit var root: Path + + @ParameterizedTest + @ValueSource(strings = ["unchanged", "body", "annotation", "resource"]) + fun `only unchanged shadowed production permits the selected control proof`(change: String) { + val external = projectionArchive(root.resolve("external.jar"), mapOf("sample/Value.class" to definition(1, false))) + fun revision(name: String, changed: Boolean): PreparedRevision { + val app = application(external, name, if (changed) 2 else 1) + val value = if (changed && change == "body") 3 else 2 + val annotated = changed && change == "annotation" + val resource = if (changed && change == "resource") "changed" else "original" + val owned = projectionArchive(root.resolve("$name-owned.jar"), + mapOf("sample/Value.class" to definition(value, annotated), "data.txt" to resource.toByteArray())) + val input = prepareArchiveInput(ArchiveInput("application", listOf(ArchiveEntryInput(app), + ArchiveEntryInput(external), ArchiveEntryInput(owned, application = true))), + InputProject(root.resolve("unused"), emptyList(), emptyList()), root.resolve("$name-input"), 17) + val scope = input.toStaticScope(root.resolve("$name-scope")) + return PreparedRevision(name, root, mapOf("application" to scope), input.production) + } + val base = revision("base", false) + val head = revision("head", true) + fun selected(revision: PreparedRevision): ByteArray = revision.scopes.getValue("application").dependencies + .firstNotNullOf { readWarArchive(it)["sample/Value.class"] } + assertContentEquals(definition(1, false), selected(base)) + assertContentEquals(selected(base), selected(head)) + val result = GraphFoldEngine(EngineConfiguration(root.resolve("analysis"))).analyze(PreparedAnalysisRequest( + base, head, listOf(changedFile("Value.java", "Value.java")), """ + version: 1 + folds: + - match: {CallSite: {callee_class: sample.App, callee_name: enabled}} + value: false + """.trimIndent())) + assertEquals(if (change == "unchanged") Verdict.PASS else Verdict.FAIL, result.verdict, result.toString()) + assertEquals(change != "unchanged", result.diagnostics.any { it.code == DiagnosticCode.PRODUCTION_OUTPUT_CHANGED }, + result.toString()) + if (change == "unchanged") assertTrue(result.diagnostics.isEmpty(), result.toString()) + assertTrue(result.diagnostics.none { it.code == DiagnosticCode.UNMATCHED_RULE }, result.toString()) + assertEquals(2, result.ruleAudits.size) + assertTrue(result.ruleAudits.all { it.matchedCallCount == 1 }, result.toString()) + } + + private fun application(dependency: Path, side: String, treatment: Int): Path { + val source = Files.createDirectories(root.resolve("$side-source")).resolve("App.java") + Files.writeString(source, """ + package sample; + public class App { + static boolean enabled() { return false; } + public static int run() { return enabled() ? $treatment : Value.value(); } + } + """.trimIndent()) + val classes = Files.createDirectories(root.resolve("$side-compiled")) + assertEquals(0, ToolProvider.getSystemJavaCompiler().run(null, null, null, + "--release", "17", "-g:none", "-cp", dependency.toString(), "-d", classes.toString(), source.toString())) + return projectionArchive(root.resolve("$side-application.jar"), + mapOf("sample/App.class" to Files.readAllBytes(classes.resolve("sample/App.class")))) + } + + private fun definition(value: Int, annotated: Boolean): ByteArray = ClassWriter(0).apply { + visit(Opcodes.V17, Opcodes.ACC_PUBLIC or Opcodes.ACC_SUPER, "sample/Value", null, "java/lang/Object", null) + if (annotated) visitAnnotation("Ljava/lang/Deprecated;", true).visitEnd() + visitMethod(Opcodes.ACC_PUBLIC or Opcodes.ACC_STATIC, "value", "()I", null, null).apply { + visitCode(); visitLdcInsn(value); visitInsn(Opcodes.IRETURN); visitMaxs(1, 0); visitEnd() + } + visitEnd() + }.toByteArray() +} diff --git a/engine/src/test/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/SignedArchiveProjectionTest.kt b/engine/src/test/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/SignedArchiveProjectionTest.kt new file mode 100644 index 00000000..c6d6aeb1 --- /dev/null +++ b/engine/src/test/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/SignedArchiveProjectionTest.kt @@ -0,0 +1,165 @@ +package io.johnsonlee.graphfold.engine.inputs.archive + +import java.nio.file.Files +import java.nio.file.Path +import java.security.MessageDigest +import java.util.jar.JarFile +import java.util.zip.ZipFile +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.io.TempDir +import org.junit.jupiter.params.ParameterizedTest +import org.junit.jupiter.params.provider.CsvSource +import org.junit.jupiter.params.provider.ValueSource +import org.objectweb.asm.ClassWriter +import org.objectweb.asm.Opcodes +import kotlin.test.assertContentEquals +import kotlin.test.assertEquals +import kotlin.test.assertFailsWith +import kotlin.test.assertFalse +import kotlin.test.assertTrue + +class SignedArchiveProjectionTest { + @TempDir lateinit var temporary: Path + + @ParameterizedTest + @CsvSource("jar,8", "jar,17", "boot,8", "boot,17", "war,8", "war,17") + fun `signed MR packaged inputs retain evidence and select only the build JDK`(layout: String, javaVersion: Int) { + val library = signedArchive(multiRelease = true) + val original = Files.readAllBytes(library) + val archive = when (layout) { + "boot" -> projectionArchive(temporary.resolve("app.jar"), mapOf("BOOT-INF/lib/library.jar" to original)) + "war" -> projectionArchive(temporary.resolve("app.war"), mapOf("WEB-INF/lib/library.jar" to original)) + else -> library + } + val input = InputProject(Files.createDirectory(temporary.resolve("compiler")), emptyList(), emptyList()) + val result = prepareArchiveInput(ArchiveInput("app", listOf(ArchiveEntryInput(archive))), input, + temporary.resolve("prepared"), variantThreshold = javaVersion) + val expected = bytecode(if (javaVersion < 17) 1 else 2) + val owned = result.classes.resolve("sample/Value.class") + val observed = if (Files.exists(owned)) Files.readAllBytes(owned) else result.dependencies.firstNotNullOf { path -> + JarFile(path.toFile()).use { jar -> jar.getJarEntry("sample/Value.class")?.let { jar.getInputStream(it).readBytes() } } + } + assertContentEquals(expected, observed) + result.dependencies.forEach(::readVerified) + assertContentEquals(original, Files.readAllBytes(library)) + val resources = requireNotNull(result.production).entries + ZipFile(library.toFile()).use { jar -> + jar.entries().asSequence().filter { archiveSignature(it.name) || it.name == JarFile.MANIFEST_NAME }.forEach { entry -> + val hash = sha(jar.getInputStream(entry).use { it.readBytes() }) + assertTrue(resources.any { (name, value) -> name.endsWith("/${entry.name}") && value == hash }, entry.name) + } + } + } + + @Test fun `direct signed MR dependency projects without stale signing blocks`() { + val library = signedArchive(multiRelease = true) + val original = Files.readAllBytes(library) + val output = normalizeDependencyInputs(listOf(library), temporary.resolve("normalized"), variantThreshold = 17).single() + assertUnsignedSelected(output, bytecode(2)) + assertContentEquals(original, Files.readAllBytes(library)) + readVerified(library) + } + + @Test fun `unchanged signed ordinary dependency retains the original signed archive`() { + val library = signedArchive(multiRelease = false) + assertEquals(library, selectedArchiveInventory(library, 17, temporary.resolve("inventory/view.jar"))) + assertEquals(library, normalizeDependencyInputs(listOf(library), temporary.resolve("normalized"), variantThreshold = 17).single()) + readVerified(library) + JarFile(library.toFile()).use { jar -> + val entry = jar.getJarEntry("sample/Value.class") + jar.getInputStream(entry).use { it.readBytes() } + assertTrue(entry.codeSigners.isNotEmpty()) + } + } + + @Test fun `manifest projection removes signing blocks but keeps original evidence`() { + val library = signedArchive(multiRelease = false, attributes = mapOf("Class-Path" to "other.jar")) + val original = Files.readAllBytes(library) + val output = normalizePackagedArchive(library, temporary.resolve("normalized/library.jar")) + assertUnsignedSelected(output, bytecode(1)) + assertContentEquals(original, Files.readAllBytes(library)) + readVerified(library) + } + + @Test fun `projected exploded signed archive omits stale signing blocks`() { + val library = signedArchive(multiRelease = true) + val directory = Files.createDirectory(temporary.resolve("exploded")) + ZipFile(library.toFile()).use { jar -> + jar.entries().asSequence().filterNot { it.isDirectory }.forEach { entry -> + val target = directory.resolve(entry.name) + Files.createDirectories(target.parent) + jar.getInputStream(entry).use { Files.copy(it, target) } + } + } + val result = normalizeDependencyInputs(listOf(directory), temporary.resolve("normalized")).single() + assertUnsignedSelected(result, bytecode(1)) + assertTrue(Files.exists(directory.resolve("META-INF/TEST.SF"))) + } + + @Test fun `tampered signed source is rejected before a projection can hide it`() { + val library = signedArchive(multiRelease = true) + val entries = ZipFile(library.toFile()).use { jar -> jar.entries().asSequence().associate { entry -> + entry.name to jar.getInputStream(entry).use { it.readBytes() } + } }.toMutableMap() + entries["META-INF/versions/17/sample/Value.class"] = bytecode(3) + val tampered = projectionArchive(temporary.resolve("tampered.jar"), entries) + assertFailsWith { + selectedArchiveInventory(tampered, 17, temporary.resolve("inventory/view.jar")) + } + assertFailsWith { + normalizeDependencyInputs(listOf(tampered), temporary.resolve("normalized"), variantThreshold = 17) + } + } + + @ParameterizedTest + @ValueSource(strings = ["META-INF/KEY.SF", "meta-inf/key.rsa", "META-INF/KEY.DSA", "META-INF/KEY.EC", "META-INF/SIG-CUSTOM"]) + fun `root signing blocks are omitted from graph projections`(name: String) { + assertTrue(archiveSignature(name)) + } + + @ParameterizedTest + @ValueSource(strings = ["OTHER/KEY.SF", "META-INF/services/KEY.SF", "META-INF/MANIFEST.MF", "META-INF/key.txt"]) + fun `ordinary resources are not signing blocks`(name: String) { + assertFalse(archiveSignature(name)) + } + + private fun signedArchive(multiRelease: Boolean, attributes: Map = emptyMap()): Path { + val entries = linkedMapOf("sample/Value.class" to bytecode(1), "settings.properties" to "value=1\n".toByteArray()) + if (multiRelease) entries["META-INF/versions/17/sample/Value.class"] = bytecode(2) + val manifest = if (multiRelease) attributes + ("Multi-Release" to "true") else attributes + val archive = projectionArchive(temporary.resolve("library.jar"), entries, manifest) + val key = temporary.resolve("test.p12") + runTool("keytool", "-genkeypair", "-alias", "test", "-keyalg", "RSA", "-keysize", "2048", "-validity", "1", + "-dname", "CN=GraphFold test", "-storetype", "PKCS12", "-keystore", key.toString(), "-storepass", "testpass", "-noprompt") + runTool("jarsigner", "-keystore", key.toString(), "-storepass", "testpass", archive.toString(), "test") + readVerified(archive) + return archive + } + + private fun runTool(tool: String, vararg arguments: String) { + val executable = Path.of(System.getProperty("java.home"), "bin", tool) + val process = ProcessBuilder(listOf(executable.toString()) + arguments).redirectErrorStream(true).start() + val output = process.inputStream.bufferedReader().use { it.readText() } + assertEquals(0, process.waitFor(), "$tool: $output") + } + + private fun readVerified(path: Path) = JarFile(path.toFile()).use { jar -> + jar.entries().asSequence().filterNot { it.isDirectory }.forEach { jar.getInputStream(it).use { input -> input.readBytes() } } + } + + private fun assertUnsignedSelected(path: Path, expected: ByteArray) = JarFile(path.toFile()).use { jar -> + assertFalse(jar.entries().asSequence().any { archiveSignature(it.name) }) + assertContentEquals(expected, jar.getInputStream(jar.getJarEntry("sample/Value.class")).use { it.readBytes() }) + readVerified(path) + } + + private fun bytecode(value: Int): ByteArray = ClassWriter(0).apply { + visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "sample/Value", null, "java/lang/Object", null) + visitMethod(Opcodes.ACC_PUBLIC or Opcodes.ACC_STATIC, "value", "()I", null, null).apply { + visitCode(); visitLdcInsn(value); visitInsn(Opcodes.IRETURN); visitMaxs(1, 0); visitEnd() + } + visitEnd() + }.toByteArray() + + private fun sha(bytes: ByteArray): String = MessageDigest.getInstance("SHA-256").digest(bytes).joinToString("") { "%02x".format(it) } +} diff --git a/engine/src/test/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/SpringBootArchiveInputTest.kt b/engine/src/test/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/SpringBootArchiveInputTest.kt index 8765c23b..0acda3ef 100644 --- a/engine/src/test/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/SpringBootArchiveInputTest.kt +++ b/engine/src/test/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/SpringBootArchiveInputTest.kt @@ -29,7 +29,7 @@ class SpringBootArchiveInputTest { val archive = projectionArchive(root.resolve("app.jar"), entries, attributes()) val selected = ArchiveInput("boot", listOf(ArchiveEntryInput(archive, listOf(source))), producerArchives = mapOf(library to listOf(librarySource), unrelated to listOf(root.resolve("unused")))) - val actual = requireNotNull(springBootArchiveInput(selected, root.resolve("projection"))) + val actual = requireNotNull(springBootArchiveInput(selected, root.resolve("projection"))).input assertEquals(listOf(emptyList(), listOf(source), listOf(librarySource)), actual.classpath.map { it.producerOutputs }) assertEquals(mapOf("kind" to "spring-boot"), actual.archiveMetadata) val classes = readWarArchive(actual.classpath[1].artifact) @@ -51,7 +51,7 @@ class SpringBootArchiveInputTest { if (mapped) mapOf(library to listOf(librarySource)) else emptyMap() val selected = requireNotNull(springBootArchiveInput(ArchiveInput("boot", listOf(ArchiveEntryInput(archive, listOf(root.resolve("classes")))), producerArchives = producers), - root.resolve("out"))) + root.resolve("out"))).input val projectedLibrary = selected.classpath.last() assertContentEquals(Files.readAllBytes(library), Files.readAllBytes(projectedLibrary.artifact)) assertEquals(if (mapped) listOf(librarySource) else emptyList(), projectedLibrary.producerOutputs) @@ -101,7 +101,7 @@ class SpringBootArchiveInputTest { val archive = projectionArchive(root.resolve("layout.jar"), mapOf("BOOT-INF/classes/sample/App.class" to bytecode("sample/App")), attributes) val selected = requireNotNull(springBootArchiveInput(ArchiveInput("boot", - listOf(ArchiveEntryInput(archive, listOf(root.resolve("classes"))))), root.resolve("out"))) + listOf(ArchiveEntryInput(archive, listOf(root.resolve("classes"))))), root.resolve("out"))).input assertEquals(setOf("kind"), selected.archiveMetadata.keys) assertEquals("spring-boot", selected.archiveMetadata["kind"]) val classes = selected.classpath.single { it.producerOutputs.isNotEmpty() } diff --git a/engine/src/test/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/StaticClasspathOrderCacheTest.kt b/engine/src/test/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/StaticClasspathOrderCacheTest.kt new file mode 100644 index 00000000..70e0fc2c --- /dev/null +++ b/engine/src/test/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/StaticClasspathOrderCacheTest.kt @@ -0,0 +1,60 @@ +package io.johnsonlee.graphfold.engine.inputs.archive + +import java.nio.file.Files +import java.nio.file.Path +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.io.TempDir +import org.objectweb.asm.ClassWriter +import org.objectweb.asm.Opcodes +import kotlin.test.assertContentEquals +import kotlin.test.assertEquals +import kotlin.test.assertFailsWith +import kotlin.test.assertFalse + +class StaticClasspathOrderCacheTest { + @TempDir lateinit var root: Path + private val cache = DependencyInputCache() + private var sequence = 0 + + @Test fun `cache preserves first definition when explicit order reverses`() { + val first = library("first", 1) + val second = library("second", 2) + val forward = normalize(listOf(first, second), StaticClassOrder.EXPLICIT_ORDER) + val reversed = normalize(listOf(second, first), StaticClassOrder.EXPLICIT_ORDER) + assertContentEquals(bytes(1), readWarArchive(forward.first()).getValue("Value.class")) + assertContentEquals(bytes(2), readWarArchive(reversed.first()).getValue("Value.class")) + assertFalse("Value.class" in readWarArchive(forward.last())) + assertFalse("Value.class" in readWarArchive(reversed.last())) + assertEquals(forward, normalize(listOf(first, second), StaticClassOrder.EXPLICIT_ORDER)) + } + + @Test fun `explicit-order cache entry cannot bypass an unambiguous-policy obligation`() { + val dependencies = listOf(library("first", 1), library("second", 2)) + normalize(dependencies, StaticClassOrder.EXPLICIT_ORDER) + assertFailsWith { normalize(dependencies, StaticClassOrder.UNAMBIGUOUS) } + assertContentEquals(bytes(1), readWarArchive(normalize(dependencies, StaticClassOrder.EXPLICIT_ORDER).first()) + .getValue("Value.class")) + } + + @Test fun `application-first cache selection still distinguishes explicit and unambiguous policies`() { + val dependency = library("dependency", 2) + val application = Files.createDirectory(root.resolve("application")) + Files.write(application.resolve("Value.class"), bytes(1)) + val selected = normalize(listOf(dependency), StaticClassOrder.EXPLICIT_ORDER, application) + assertFalse("Value.class" in readWarArchive(selected.single())) + assertFailsWith { normalize(listOf(dependency), StaticClassOrder.UNAMBIGUOUS, application) } + } + + private fun normalize(inputs: List, policy: StaticClassOrder, application: Path? = null): List = + normalizeDependencyInputs(inputs, root.resolve("normalized-${sequence++}"), applicationClasses = application, + cache = cache, classOrder = policy) + + private fun library(name: String, value: Int): Path = projectionArchive(root.resolve("$name.jar"), + mapOf("Value.class" to bytes(value))) + + private fun bytes(value: Int): ByteArray = ClassWriter(0).apply { + visit(Opcodes.V17, Opcodes.ACC_PUBLIC, "Value", null, "java/lang/Object", null) + visitField(Opcodes.ACC_PUBLIC or Opcodes.ACC_STATIC or Opcodes.ACC_FINAL, "VALUE", "I", null, value).visitEnd() + visitEnd() + }.toByteArray() +} diff --git a/engine/src/test/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/StaticClasspathOrderTest.kt b/engine/src/test/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/StaticClasspathOrderTest.kt new file mode 100644 index 00000000..6e58d82b --- /dev/null +++ b/engine/src/test/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/StaticClasspathOrderTest.kt @@ -0,0 +1,163 @@ +package io.johnsonlee.graphfold.engine.inputs.archive + +import io.johnsonlee.graphfold.engine.DiagnosticCode +import io.johnsonlee.graphfold.engine.InputChangeProof +import io.johnsonlee.graphfold.engine.git.changedFile +import java.nio.file.Files +import java.nio.file.Path +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.io.TempDir +import org.junit.jupiter.params.ParameterizedTest +import org.junit.jupiter.params.provider.ValueSource +import org.objectweb.asm.ClassWriter +import org.objectweb.asm.Opcodes +import kotlin.test.assertContentEquals +import kotlin.test.assertEquals +import kotlin.test.assertFailsWith +import kotlin.test.assertFalse +import kotlin.test.assertNotNull +import kotlin.test.assertTrue + +class StaticClasspathOrderTest { + @TempDir lateinit var root: Path + private var sequence = 0 + + @Test fun `complete Boot index selects annotated bytes ahead of ZIP and filename order`() { + val first = library("a", definition(1)) + val indexed = library("z", definition(1, "indexed")) + val boot = boot(first, indexed, "- \"BOOT-INF/lib/z.jar\"\n- \"BOOT-INF/lib/a.jar\"\n") + val prepared = prepare(ArchiveInput("boot", listOf(ArchiveEntryInput(boot)))) + assertContentEquals(definition(1, "indexed"), selected(prepared, "sample/Value.class")) + assertTrue(prepared.production!!.nonClassEntries.keys.any { it.endsWith("BOOT-INF/classpath.idx") }) + } + + @Test fun `blank lines preserve the declared Boot index order`() { + val first = library("a", definition(1)) + val indexed = library("z", definition(2)) + val archive = boot(first, indexed, "\n \n- \"BOOT-INF/lib/z.jar\"\n\t\n- \"BOOT-INF/lib/a.jar\"\n") + assertContentEquals(definition(2), selected(prepare(ArchiveInput("boot", listOf(ArchiveEntryInput(archive)))), + "sample/Value.class")) + } + + @Test fun `WAR accepts an explicitly provided API archive without a container or index`() { + val dependency = library("api", definition(7)) + val archive = projectionArchive(root.resolve("app.war"), + mapOf("WEB-INF/classes/sample/App.class" to definition(0, owner = "sample/App"))) + val input = ArchiveInput("war", listOf(ArchiveEntryInput(archive)), staticDependencies = listOf(dependency)) + assertContentEquals(definition(7), selected(prepare(input), "sample/Value.class")) + } + + @ParameterizedTest + @ValueSource(booleans = [false, true]) + fun `explicit integration order selects first library independently of names`(reverse: Boolean) { + val primary = primary() + val libraries = listOf(library("z", definition(1)), library("a", definition(2))) + val ordered = if (reverse) libraries.reversed() else libraries + val prepared = prepare(ArchiveInput("ordered", (listOf(primary) + ordered).map(::ArchiveEntryInput))) + assertContentEquals(definition(if (reverse) 2 else 1), selected(prepared, "sample/Value.class")) + } + + @ParameterizedTest + @ValueSource(booleans = [false, true]) + fun `later owned copy retains role only when it matches selected bytes`(identical: Boolean) { + val external = library("external", definition(1)) + val owned = library("owned", definition(if (identical) 1 else 2)) + val prepared = prepare(ArchiveInput("ownership", listOf(ArchiveEntryInput(primary()), ArchiveEntryInput(external), + ArchiveEntryInput(owned, application = true)))) + assertEquals(identical, Files.exists(prepared.classes.resolve("sample/Value.class"))) + assertContentEquals(definition(1), selected(prepared, "sample/Value.class")) + val inventory = requireNotNull(prepared.production) + assertEquals(!identical, "artifact/1/sample/Value.class" in inventory.nonClassEntries) + } + + @Test fun `later owned multi release copy uses the build selected definition for ownership`() { + val external = library("external", definition(17)) + val owned = projectionArchive(root.resolve("owned.jar"), mapOf("sample/Value.class" to definition(8), + "META-INF/versions/17/sample/Value.class" to definition(17)), mapOf("Multi-Release" to "true")) + val prepared = prepare(ArchiveInput("ownership", listOf(ArchiveEntryInput(primary()), ArchiveEntryInput(external), + ArchiveEntryInput(owned, application = true)))) + assertContentEquals(definition(17), Files.readAllBytes(prepared.classes.resolve("sample/Value.class"))) + assertFalse("artifact/1/sample/Value.class" in prepared.production!!.nonClassEntries) + } + + @ParameterizedTest + @ValueSource(strings = ["body", "annotation", "resource"]) + fun `shadowed production changes retain an undischarged obligation`(change: String) { + val external = library("external", definition(1)) + fun revision(changed: Boolean): InputProject { + val bytes = definition(if (changed && change == "body") 3 else 2, + if (changed && change == "annotation") "changed" else "original") + val owned = library("owned-${sequence++}", bytes, + if (changed && change == "resource") "changed" else "original") + return prepare(ArchiveInput("ownership", listOf(ArchiveEntryInput(primary()), ArchiveEntryInput(external), + ArchiveEntryInput(owned, application = true)))) + } + val base = revision(false) + val head = revision(true) + assertContentEquals(selected(base, "sample/Value.class"), selected(head, "sample/Value.class")) + val proof = InputChangeProof(listOf(changedFile("Library.java", "Library.java")), base.production, head.production) + assertFalse(proof.unchanged) + assertEquals(DiagnosticCode.PRODUCTION_OUTPUT_CHANGED, assertNotNull(proof.gap()).code) + assertNotNull(proof.gap(resourcesProved = true), "Resource proof must not discard a shadowed class or opaque resource") + } + + @ParameterizedTest + @ValueSource(strings = ["missing", "incomplete", "malformed", "duplicate", "unknown"]) + fun `optional unusable index does not prevent unambiguous Boot input`(mode: String) { + val index = when (mode) { + "missing" -> null + "incomplete" -> "- \"BOOT-INF/lib/a.jar\"\n" + "malformed" -> "not an index" + "duplicate" -> "- \"BOOT-INF/lib/a.jar\"\n- \"BOOT-INF/lib/a.jar\"\n" + else -> "- \"BOOT-INF/lib/unknown.jar\"\n- \"BOOT-INF/lib/z.jar\"\n" + } + val first = library("a", definition(1)) + val second = library("z", definition(1)) + val archive = boot(first, second, index) + val projection = assertNotNull(springBootArchiveInput(ArchiveInput("boot", listOf(ArchiveEntryInput(archive))), + root.resolve("decode-${sequence++}"))) + assertEquals(StaticClassOrder.UNAMBIGUOUS, projection.classOrder) + assertContentEquals(definition(1), selected(prepare(ArchiveInput("boot", listOf(ArchiveEntryInput(archive)))), + "sample/Value.class")) + } + + @ParameterizedTest + @ValueSource(strings = ["boot", "war"]) + fun `ZIP position alone does not resolve different definitions without declared order`(kind: String) { + val first = library("a", definition(1)) + val second = library("z", definition(2)) + val archive = if (kind == "boot") boot(first, second, null) else projectionArchive(root.resolve("app.war"), mapOf( + "WEB-INF/classes/sample/App.class" to definition(0, owner = "sample/App"), + "WEB-INF/lib/z.jar" to Files.readAllBytes(second), "WEB-INF/lib/a.jar" to Files.readAllBytes(first))) + assertFailsWith { prepare(ArchiveInput(kind, listOf(ArchiveEntryInput(archive)))) } + } + + private fun primary(): Path = projectionArchive(root.resolve("primary-${sequence++}.jar"), + mapOf("sample/App.class" to definition(0, owner = "sample/App"))) + + private fun library(name: String, bytes: ByteArray, resource: String = "unchanged"): Path = + projectionArchive(root.resolve("$name.jar"), mapOf("sample/Value.class" to bytes, "data.txt" to resource.toByteArray())) + + private fun boot(first: Path, second: Path, index: String?): Path = projectionArchive(root.resolve("boot-${sequence++}.jar"), + linkedMapOf("BOOT-INF/lib/a.jar" to Files.readAllBytes(first), "BOOT-INF/lib/z.jar" to Files.readAllBytes(second), + "BOOT-INF/classes/sample/App.class" to definition(0, owner = "sample/App")) + + if (index == null) emptyMap() else mapOf("BOOT-INF/classpath.idx" to index.toByteArray())) + + private fun prepare(input: ArchiveInput): InputProject = prepareArchiveInput(input, + InputProject(root.resolve("unused"), emptyList(), emptyList()), root.resolve("prepared-${sequence++}"), 17) + + private fun selected(input: InputProject, name: String): ByteArray { + val application = input.classes.resolve(name) + return if (Files.isRegularFile(application)) Files.readAllBytes(application) + else input.dependencies.firstNotNullOf { readWarArchive(it)[name] } + } + + private fun definition(value: Int, annotation: String? = null, owner: String = "sample/Value"): ByteArray = ClassWriter(0).apply { + visit(Opcodes.V17, Opcodes.ACC_PUBLIC or Opcodes.ACC_SUPER, owner, null, "java/lang/Object", null) + if (annotation != null) visitAnnotation("Lsample/Metadata;", false).apply { visit("value", annotation); visitEnd() } + visitMethod(Opcodes.ACC_PUBLIC or Opcodes.ACC_STATIC, "value", "()I", null, null).apply { + visitCode(); visitLdcInsn(value); visitInsn(Opcodes.IRETURN); visitMaxs(1, 0); visitEnd() + } + visitEnd() + }.toByteArray() +} diff --git a/engine/src/test/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/WarArchiveInputTest.kt b/engine/src/test/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/WarArchiveInputTest.kt index 25e3c462..8587d5cf 100644 --- a/engine/src/test/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/WarArchiveInputTest.kt +++ b/engine/src/test/kotlin/io/johnsonlee/graphfold/engine/inputs/archive/WarArchiveInputTest.kt @@ -28,7 +28,7 @@ class WarArchiveInputTest { val selected = ArchiveInput("web", listOf(ArchiveEntryInput(war, listOf(classes))), producerArchives = mapOf(library to listOf(libraryClasses), other to listOf(root.resolve("unused")), root.resolve("missing.jar") to listOf(root.resolve("missing-classes")))) - val actual = requireNotNull(warArchiveInput(selected, root.resolve("out"))) + val actual = requireNotNull(warArchiveInput(selected, root.resolve("out"))).input val application = actual.classpath.indexOfFirst { it.producerOutputs == listOf(classes) } val libraryIndex = actual.classpath.indexOfFirst { it.producerOutputs == listOf(libraryClasses) } assertTrue(application >= 0 && libraryIndex == application + 1) @@ -45,7 +45,7 @@ class WarArchiveInputTest { val provided = Files.createDirectories(root.resolve("api/package")) Files.writeString(provided.resolve("Type.class"), "external type bytes") val input = ArchiveInput("web", listOf(ArchiveEntryInput(war)), staticDependencies = listOf(provided.parent)) - val projected = requireNotNull(warArchiveInput(input, root.resolve("out"))) + val projected = requireNotNull(warArchiveInput(input, root.resolve("out"))).input val dependency = projected.classpath.single { readWarArchive(it.artifact).containsKey("package/Type.class") } assertTrue(!dependency.application && dependency.producerOutputs.isEmpty()) assertEquals("external type bytes", readWarArchive(dependency.artifact).getValue("package/Type.class").decodeToString()) @@ -74,7 +74,7 @@ class WarArchiveInputTest { val second = library("second.jar", if (different) 2 else 1) val war = projectionArchive(root.resolve("app.war"), mapOf("WEB-INF/lib/one.jar" to Files.readAllBytes(first), "WEB-INF/lib/two.jar" to Files.readAllBytes(second))) - val expanded = requireNotNull(warArchiveInput(ArchiveInput("web", listOf(ArchiveEntryInput(war))), root.resolve("out"))) + val expanded = requireNotNull(warArchiveInput(ArchiveInput("web", listOf(ArchiveEntryInput(war))), root.resolve("out"))).input val normalize = { normalizeDependencyInputs(expanded.classpath.filterNot { it.inventoryOnly }.map { it.artifact }, root.resolve("normalized")) @@ -101,7 +101,7 @@ class WarArchiveInputTest { } val war = projectionArchive(root.resolve("app.war"), mapOf( "WEB-INF/lib/first.jar" to library("first"), "WEB-INF/lib/second.jar" to library("second"))) - val expanded = requireNotNull(warArchiveInput(ArchiveInput("web", listOf(ArchiveEntryInput(war))), root.resolve("out"))) + val expanded = requireNotNull(warArchiveInput(ArchiveInput("web", listOf(ArchiveEntryInput(war))), root.resolve("out"))).input for (variant in listOf(0, 9)) { val inputs = normalizeDependencyInputs(expanded.classpath.filterNot { it.inventoryOnly }.map { it.artifact }, root.resolve("variant-$variant"), variantThreshold = variant) diff --git a/plugin/gradle/src/test/kotlin/io/johnsonlee/graphfold/gradle/ArchiveClasspathIntegrationTest.kt b/plugin/gradle/src/test/kotlin/io/johnsonlee/graphfold/gradle/ArchiveClasspathIntegrationTest.kt index 743d9464..3c79389c 100644 --- a/plugin/gradle/src/test/kotlin/io/johnsonlee/graphfold/gradle/ArchiveClasspathIntegrationTest.kt +++ b/plugin/gradle/src/test/kotlin/io/johnsonlee/graphfold/gradle/ArchiveClasspathIntegrationTest.kt @@ -20,8 +20,6 @@ import org.junit.jupiter.api.io.TempDir import org.junit.jupiter.params.ParameterizedTest import org.junit.jupiter.params.provider.CsvSource import org.junit.jupiter.params.provider.ValueSource -import io.johnsonlee.graphfold.engine.inputs.archive.InputFailure -import kotlin.test.assertFailsWith import kotlin.test.assertEquals import kotlin.test.assertTrue @@ -368,15 +366,18 @@ class ArchiveClasspathIntegrationTest { assertTrue(result.diagnostics.none { it.code == DiagnosticCode.ANALYSIS_FAILED }, result.toString()) } - @Test fun `conflicting definitions in one selected scope remain an explicit input failure`() { + @Test fun `explicit model classpath order supports controlled changes with repeated definitions`() { val repository = repository() val build = repository.resolve("build.gradle") Files.writeString(build, Files.readString(build).replace("files(rootProject.file('libs/second.jar'))", "files(rootProject.file('libs/second.jar'), rootProject.file('libs/first.jar'))")) val base = commit(repository) write(repository, "two/src/main/java/two/App.java", program("two", "12", "")) - val failure = assertFailsWith { analyze(repository, base) } - assertTrue(failure.message.contains("library/Value"), failure.message) + val result = analyze(repository, base) + assertEquals(Verdict.PASS, result.verdict, result.toString()) + assertTrue(result.diagnostics.isEmpty(), result.toString()) + assertTrue(result.findings.isEmpty(), result.toString()) + assertTrue(result.ruleAudits.all { it.matchedCallCount == 1 }, result.toString()) } private fun analyze(repository: Path, base: String): AnalysisResult = diff --git a/plugin/gradle/src/test/kotlin/io/johnsonlee/graphfold/gradle/SpringBootArchiveGoldenTest.kt b/plugin/gradle/src/test/kotlin/io/johnsonlee/graphfold/gradle/SpringBootArchiveGoldenTest.kt index 75e622e4..094f536b 100644 --- a/plugin/gradle/src/test/kotlin/io/johnsonlee/graphfold/gradle/SpringBootArchiveGoldenTest.kt +++ b/plugin/gradle/src/test/kotlin/io/johnsonlee/graphfold/gradle/SpringBootArchiveGoldenTest.kt @@ -102,7 +102,10 @@ class SpringBootArchiveGoldenTest { private fun project(): Path { val root = Files.createDirectory(temporary.resolve("project")) Files.writeString(root.resolve(".gitignore"), ".gradle/\nbuild/\n") - Files.writeString(root.resolve("settings.gradle"), "rootProject.name='parent'; include 'library', 'boot'") + Files.writeString(root.resolve("settings.gradle"), """ + pluginManagement { repositories { mavenCentral(); gradlePluginPortal() } } + rootProject.name='parent'; include 'library', 'boot' + """.trimIndent()) Files.writeString(root.resolve("build.gradle"), """ plugins { id 'io.johnsonlee.graphfold'; id 'org.springframework.boot' version '3.5.7' apply false } allprojects { group='fixture'; version='1'; repositories { mavenCentral() } } diff --git a/plugin/maven/src/main/kotlin/io/johnsonlee/graphfold/maven/MavenProjectInput.kt b/plugin/maven/src/main/kotlin/io/johnsonlee/graphfold/maven/MavenProjectInput.kt index 4fdb8591..b9dc28c4 100644 --- a/plugin/maven/src/main/kotlin/io/johnsonlee/graphfold/maven/MavenProjectInput.kt +++ b/plugin/maven/src/main/kotlin/io/johnsonlee/graphfold/maven/MavenProjectInput.kt @@ -11,8 +11,8 @@ import org.apache.maven.project.MavenProject internal fun MavenProject.staticInput(javaVersion: Int, reactor: List = emptyList()): ArchiveScopeInput { val archive = requireNotNull(artifact?.file) { "Package the Maven project before exporting GraphFold inputs" }.toPath() require(Files.isRegularFile(archive)) { "Packaged Maven artifact is missing: $archive" } - val selected = artifacts.filter { it.scope in INPUT_SCOPES } - val resolved = selected.associateWith { dependency -> + val (runtime, supplemental) = artifacts.filter { it.isClasspathInput() }.partition { it.scope in RUNTIME_SCOPES } + val resolved = (runtime + supplemental).associateWith { dependency -> val file = requireNotNull(dependency.file) { "Maven dependency has no resolved artifact: ${dependency.id}" }.toPath() require(Files.isRegularFile(file)) { "Resolved Maven dependency is missing: $file" } file.toRealPath() @@ -30,7 +30,7 @@ internal fun MavenProject.staticInput(javaVersion: Int, reactor: List - val dependencies = producer.artifacts.filter { it.scope in INPUT_SCOPES }.mapNotNull { it.file?.toPath() } + val dependencies = producer.artifacts.filter { it.isClasspathInput() }.mapNotNull { it.file?.toPath() } producer.compileSourceRoots.map { Path.of(it).toAbsolutePath().normalize() to dependencies } }.toMap() return ArchiveScopeInput(identity(), archive.toRealPath(), resolved.values.distinct(), sourceOutputs.keys.toList(), @@ -38,7 +38,10 @@ internal fun MavenProject.staticInput(javaVersion: Int, reactor: List listOf(producer.classes()) }, javaVersion = javaVersion) } +private fun Artifact.isClasspathInput() = scope in INPUT_SCOPES && artifactHandler.isAddedToClasspath + private fun MavenProject.identity() = "$groupId:$artifactId" private fun MavenProject.classes(): Path = Path.of(build.outputDirectory).toAbsolutePath().normalize() -private val INPUT_SCOPES = setOf(Artifact.SCOPE_COMPILE, Artifact.SCOPE_RUNTIME, Artifact.SCOPE_PROVIDED, Artifact.SCOPE_SYSTEM) +private val RUNTIME_SCOPES = setOf(Artifact.SCOPE_COMPILE, Artifact.SCOPE_RUNTIME) +private val INPUT_SCOPES = RUNTIME_SCOPES + setOf(Artifact.SCOPE_PROVIDED, Artifact.SCOPE_SYSTEM) diff --git a/plugin/maven/src/test/kotlin/io/johnsonlee/graphfold/maven/MavenDependencyOrderTest.kt b/plugin/maven/src/test/kotlin/io/johnsonlee/graphfold/maven/MavenDependencyOrderTest.kt new file mode 100644 index 00000000..a019b787 --- /dev/null +++ b/plugin/maven/src/test/kotlin/io/johnsonlee/graphfold/maven/MavenDependencyOrderTest.kt @@ -0,0 +1,113 @@ +package io.johnsonlee.graphfold.maven + +import io.johnsonlee.graphfold.engine.inputs.StaticInputSnapshots +import java.nio.file.Files +import java.nio.file.Path +import java.util.jar.JarEntry +import java.util.jar.JarFile +import java.util.jar.JarOutputStream +import javax.tools.ToolProvider +import org.apache.maven.artifact.Artifact +import org.apache.maven.artifact.DefaultArtifact +import org.apache.maven.artifact.handler.DefaultArtifactHandler +import org.apache.maven.model.Build +import org.apache.maven.model.Model +import org.apache.maven.project.MavenProject +import org.eclipse.jgit.api.Git +import org.junit.jupiter.api.io.TempDir +import org.junit.jupiter.params.ParameterizedTest +import org.junit.jupiter.params.provider.CsvSource +import kotlin.test.assertContentEquals +import kotlin.test.assertEquals +import kotlin.test.assertNotEquals +import kotlin.test.assertNotNull +import kotlin.test.assertTrue + +class MavenDependencyOrderTest { + @TempDir lateinit var temporary: Path + + @ParameterizedTest + @CsvSource("provided,compile", "provided,runtime", "system,compile", "system,runtime") + fun `runtime definition wins while supplemental class changes remain inventoried`(supplementalScope: String, runtimeScope: String) { + val repository = Files.createDirectories(temporary.resolve("repository")) + Files.writeString(repository.resolve("pom.xml"), "") + val primary = artifact("application", Artifact.SCOPE_COMPILE, "App", 0) + val supplemental = artifact("supplemental", supplementalScope, "Value", 7) + val runtime = artifact("runtime", runtimeScope, "Value", 9) + val excluded = listOf("tar.gz", "jar").map { type -> + DefaultArtifact("fixture", "native-$type", "1", Artifact.SCOPE_COMPILE, type, null, + DefaultArtifactHandler(type).apply { isAddedToClasspath = false }).apply { + file = Files.writeString(temporary.resolve("native.$type"), "not a classpath archive").toFile() + } + } + val project = MavenProject(Model().apply { + groupId = "fixture" + artifactId = "application" + version = "1" + build = Build().apply { outputDirectory = temporary.resolve("application/classes").toString() } + }).apply { + file = repository.resolve("pom.xml").toFile() + artifact = primary + artifacts = (excluded + listOf(supplemental, runtime)).toSet() + } + Git.init().setDirectory(repository.toFile()).call().close() + val baseSha = commit(repository) + val base = StaticInputSnapshots.write(repository, temporary.resolve("base/snapshot.json"), listOf(project.staticInput(17))) + artifact("supplemental", supplementalScope, "Value", 8) + Files.writeString(repository.resolve("pom.xml"), "") + commit(repository) + val input = project.staticInput(17) + assertEquals(listOf(runtime.file.toPath().toRealPath(), supplemental.file.toPath().toRealPath()), input.dependencies) + val head = StaticInputSnapshots.write(repository, temporary.resolve("head/snapshot.json"), listOf(input)) + val baseCheckout = temporary.resolve("base-checkout") + Git.cloneRepository().setURI(repository.toUri().toString()).setDirectory(baseCheckout.toFile()).call().use { + it.checkout().setName(baseSha).call() + } + val (old, new) = StaticInputSnapshots.prepare(base, head, baseCheckout, repository, temporary.resolve("prepared")) + val oldScope = old.scopes.getValue(input.id) + val newScope = new.scopes.getValue(input.id) + val expected = assertNotNull(entry(runtime.file.toPath(), "sample/Value.class")) + for (scope in listOf(oldScope, newScope)) { + val definitions = scope.dependencies.mapNotNull { entry(it, "sample/Value.class") } + assertEquals(1, definitions.size) + assertContentEquals(expected, definitions.single()) + assertTrue(scope.dependencies.any { entry(it, "supplemental.txt") != null }) + } + excluded.forEach { assertEquals("not a classpath archive", Files.readString(it.file.toPath())) } + val oldEvidence = assertNotNull(oldScope.production).nonClassEntries + val newEvidence = assertNotNull(newScope.production).nonClassEntries + assertNotEquals(assertNotNull(oldEvidence["dependency/2"]), assertNotNull(newEvidence["dependency/2"]), + "The changed supplemental class must remain evidence even though the graph selects the runtime class") + } + + private fun artifact(name: String, scope: String, owner: String, value: Int): Artifact { + val directory = Files.createDirectories(temporary.resolve(name)) + val classes = Files.createDirectories(directory.resolve("classes")) + val source = Files.writeString(directory.resolve("$owner.java"), + "package sample; public class $owner { public static int value() { return $value; } }") + assertEquals(0, ToolProvider.getSystemJavaCompiler().run(null, null, null, + "--release", "17", "-g:none", "-d", classes.toString(), source.toString())) + val archive = directory.resolve("$name.jar") + JarOutputStream(Files.newOutputStream(archive)).use { jar -> + jar.putNextEntry(JarEntry("sample/$owner.class")) + Files.copy(classes.resolve("sample/$owner.class"), jar) + jar.closeEntry() + jar.putNextEntry(JarEntry("$name.txt")) + jar.write(name.toByteArray()) + jar.closeEntry() + } + return DefaultArtifact("fixture", name, "1", scope, "custom-classes", null, + DefaultArtifactHandler("custom-classes").apply { isAddedToClasspath = true }) + .apply { file = archive.toFile() } + } + + private fun entry(archive: Path, name: String): ByteArray? = JarFile(archive.toFile()).use { jar -> + jar.getJarEntry(name)?.let { jar.getInputStream(it).use { input -> input.readBytes() } } + } + + private fun commit(repository: Path): String = Git.open(repository.toFile()).use { git -> + git.add().addFilepattern(".").call() + git.commit().setMessage("model input fixture").setAuthor("GraphFold", "test@example.invalid") + .setCommitter("GraphFold", "test@example.invalid").call().name + } +} diff --git a/plugin/maven/src/test/kotlin/io/johnsonlee/graphfold/maven/MavenProjectInputTest.kt b/plugin/maven/src/test/kotlin/io/johnsonlee/graphfold/maven/MavenProjectInputTest.kt index 98a4cd07..97cd7d71 100644 --- a/plugin/maven/src/test/kotlin/io/johnsonlee/graphfold/maven/MavenProjectInputTest.kt +++ b/plugin/maven/src/test/kotlin/io/johnsonlee/graphfold/maven/MavenProjectInputTest.kt @@ -11,15 +11,17 @@ import org.apache.maven.model.Build import org.apache.maven.project.MavenProject import org.junit.jupiter.api.Test import org.junit.jupiter.api.io.TempDir +import org.junit.jupiter.params.ParameterizedTest +import org.junit.jupiter.params.provider.CsvSource import kotlin.test.assertEquals import kotlin.test.assertFailsWith class MavenProjectInputTest { @TempDir lateinit var temporary: Path - @Test fun `packaged input follows current project resolved artifacts and source roots`() { + @Test fun `packaged input prioritizes runtime artifacts while compiler mappings retain model order`() { val project = project() - val included = listOf(Artifact.SCOPE_COMPILE, Artifact.SCOPE_RUNTIME, Artifact.SCOPE_PROVIDED, Artifact.SCOPE_SYSTEM) + val included = listOf(Artifact.SCOPE_PROVIDED, Artifact.SCOPE_RUNTIME, Artifact.SCOPE_SYSTEM, Artifact.SCOPE_COMPILE) .map { dependency(it, it) } project.artifacts = (included + dependency("tests", Artifact.SCOPE_TEST)).toSet() project.addCompileSourceRoot(temporary.resolve("generated").toString()) @@ -29,7 +31,8 @@ class MavenProjectInputTest { assertEquals("fixture:library", input.id) assertEquals(17, input.javaVersion) assertEquals(project.artifact.file.toPath().toRealPath(), input.archive) - assertEquals(included.map { it.file.toPath().toRealPath() }, input.dependencies) + assertEquals(listOf(included[1], included[3], included[0], included[2]).map { it.file.toPath().toRealPath() }, + input.dependencies) assertEquals(listOf(temporary.resolve("generated")), input.sourceRoots) assertEquals(mapOf(temporary.resolve("generated") to listOf(temporary.resolve("classes"))), input.sourceOutputs) assertEquals(listOf( @@ -82,6 +85,26 @@ class MavenProjectInputTest { input.projectArtifacts.getValue(selected.artifact.file.toPath().toRealPath())) } + @ParameterizedTest + @CsvSource("compile,true", "runtime,true", "provided,true", "system,true", "test,true", + "compile,false", "runtime,false", "provided,false", "system,false", "test,false") + fun `classpath membership follows Maven artifact handler and scope`(scope: String, added: Boolean) { + val project = project() + (requireNotNull(project.artifact.artifactHandler) as DefaultArtifactHandler).isAddedToClasspath = false + val source = temporary.resolve("source") + project.addCompileSourceRoot(source.toString()) + val selected = dependency("candidate", scope).apply { + (requireNotNull(artifactHandler) as DefaultArtifactHandler).isAddedToClasspath = added + } + project.artifacts = setOf(selected) + val input = project.staticInput(17) + val nativeClasspath = (project.compileClasspathElements + project.runtimeClasspathElements) + .map { Path.of(it) }.filter { it == selected.file.toPath() }.distinct() + assertEquals(nativeClasspath.map { it.toRealPath() }, input.dependencies) + assertEquals(nativeClasspath, input.sourceClasspaths.getValue(source)) + assertEquals(project.artifact.file.toPath().toRealPath(), input.archive) + } + private fun project(): MavenProject = MavenProject(Model().apply { groupId = "fixture" artifactId = "library" @@ -90,7 +113,7 @@ class MavenProjectInputTest { }).apply { artifact = dependency("library", Artifact.SCOPE_COMPILE) } private fun dependency(name: String, scope: String): Artifact = - DefaultArtifact("fixture", name, "1", scope, "jar", null, DefaultArtifactHandler("jar")).apply { + DefaultArtifact("fixture", name, "1", scope, "jar", null, DefaultArtifactHandler("jar").apply { isAddedToClasspath = true }).apply { file = Files.write(temporary.resolve("$name.jar"), byteArrayOf()).toFile() } } diff --git a/plugin/maven/src/test/kotlin/io/johnsonlee/graphfold/maven/PackagedMavenGoldenTest.kt b/plugin/maven/src/test/kotlin/io/johnsonlee/graphfold/maven/PackagedMavenGoldenTest.kt index 549dcd29..f8fd9502 100644 --- a/plugin/maven/src/test/kotlin/io/johnsonlee/graphfold/maven/PackagedMavenGoldenTest.kt +++ b/plugin/maven/src/test/kotlin/io/johnsonlee/graphfold/maven/PackagedMavenGoldenTest.kt @@ -98,7 +98,8 @@ class PackagedMavenGoldenTest { }).apply { file = directory.resolve("pom.xml").toFile() addCompileSourceRoot(Files.createDirectories(directory.resolve("src/main/java")).toString()) - artifact = DefaultArtifact("fixture", name, "1", "compile", packaging, null, DefaultArtifactHandler(packaging)) + artifact = DefaultArtifact("fixture", name, "1", "compile", packaging, null, + DefaultArtifactHandler(packaging).apply { isAddedToClasspath = packaging == "jar" }) .apply { file = directory.resolve("target/$name.$packaging").toFile() } } }