import { ParseFailureError } from "../domain/parseFailure.js"; import { createHash } from "node:crypto"; import { writeFile } from "node:fs/promises"; import { join } from "node:path"; import { expect, it, vi } from "vitest"; import { SaxesParser } from "saxes"; import { DOMParser } from "@xmldom/xmldom"; import { createTestTempDirectory } from "../../tests/fixtures/temporaryDirectory.js"; import { mavenGradleMetadataSchema, type MavenGradleMetadata, } from "../domain/java/mavenGradleMetadata.js"; import { gradleModuleFixture, mavenPomFixture, } from "./MavenGradleMetadata.fixture.js"; import { MavenGradleMetadataProvider } from "./MavenGradleMetadataProvider.js"; import { projectAnalysisError } from "../domain/analysisErrorProjection.js"; import { parseMavenGradleMetadata } from "./MavenGradleMetadataParser.js"; const parse = (source: string, path = "/artifacts/pom.xml") => { const bytes = Buffer.from(source, "utf8"); const report = parseMavenGradleMetadata(bytes, { path, sha256: createHash("sha256").update(bytes).digest("hex"), bytes: bytes.length, }); const validated = mavenGradleMetadataSchema.safeParse(report); expect(validated.success, JSON.stringify(validated.error)).toBe(true); return report; }; it("keeps a missing child artifact separate from inheritable parent coordinates", () => { const report = parse( `4.0.0exampleparent1`, ); expect(report.coordinates).toEqual({ group_id: null, artifact_id: null, version: null, packaging: null, }); expect(report.unresolved).toEqual([ { kind: "parent-coordinate", reference: "parent.group_id", field: "group_id", owner: "project", index: null, }, { kind: "missing-coordinate", reference: "project.artifact_id", field: "artifact_id", owner: "project", index: null, }, { kind: "parent-coordinate", reference: "parent.version", field: "version", owner: "project", index: null, }, ]); }); it("preserves an opaque XML counting failure without allocating a DOM", () => { const cause = new Error("controlled XML counter failure"); const syntax = vi .spyOn(SaxesParser.prototype, "write") .mockImplementationOnce(() => { throw cause; }); const dom = vi.spyOn(DOMParser.prototype, "parseFromString"); try { let failure: unknown; try { parse(mavenPomFixture); } catch (caught) { failure = caught; } expect(failure).toBe(cause); expect(dom).not.toHaveBeenCalled(); } finally { syntax.mockRestore(); dom.mockRestore(); } }); const expectFailure = ( source: string | Uint8Array, kind: "malformed" | "unsupported", ) => { const bytes = typeof source === "string" ? Buffer.from(source, "utf8") : source; expect(() => parseMavenGradleMetadata(bytes, { path: "/artifacts/selected", sha256: createHash("sha256").update(bytes).digest("hex"), bytes: bytes.length, }), ).toThrow(ParseFailureError); try { parseMavenGradleMetadata(bytes, { path: "/artifacts/selected", sha256: createHash("sha256").update(bytes).digest("hex"), bytes: bytes.length, }); } catch (cause) { expect(cause).toBeInstanceOf(ParseFailureError); if (cause instanceof ParseFailureError) expect(cause.failure.kind).toBe(kind); } }; it("reads Maven coordinates, parent, BOM import, exclusions, ranges and unresolved properties", () => { const report = parse(mavenPomFixture); expect(report.format).toBe("maven-pom"); expect(report.coordinates).toEqual({ group_id: null, artifact_id: "demo", version: "${revision}", packaging: "jar", }); expect(report.parent).toEqual({ group_id: "com.example", artifact_id: "demo-parent", version: "9.0.0", packaging: null, relative_path: "../pom.xml", relative_path_declared: true, }); expect(report.properties).toEqual([ { name: "revision", value: "1.2.3", value_credentials_redacted: false }, { name: "jackson.version", value: "2.17.2", value_credentials_redacted: false, }, ]); expect(report.dependency_management).toEqual([ expect.objectContaining({ group_id: "org.springframework.boot", artifact_id: "spring-boot-dependencies", version: "3.3.4", version_kind: "literal", type: "pom", scope: "import", bom_import: true, origin: "dependencyManagement", }), expect.objectContaining({ group_id: "com.fasterxml.jackson.core", artifact_id: "jackson-databind", version: "${jackson.version}", version_kind: "property", origin: "dependencyManagement", bom_import: false, }), ]); expect(report.dependencies).toEqual([ expect.objectContaining({ group_id: "com.fasterxml.jackson.core", artifact_id: "jackson-databind", version: null, version_kind: "missing", scope: "compile", optional: false, optional_spelling: "false", origin: "dependencies", exclusions: [ { group_id: "com.fasterxml.jackson.core", artifact_id: "jackson-annotations", }, ], }), expect.objectContaining({ group_id: "org.junit.jupiter", artifact_id: "junit-jupiter", version: "[5.10,6.0)", version_kind: "range", scope: "test", }), ]); expect(report.unresolved).toEqual( expect.arrayContaining([ { kind: "parent-coordinate", reference: "parent.group_id", field: "group_id", owner: "project", index: null, }, { kind: "property", reference: "${revision}", field: "version", owner: "project", index: null, }, { kind: "property", reference: "${jackson.version}", field: "version", owner: "dependency_management", index: 1, }, { kind: "missing-coordinate", reference: "dependency.version", field: "version", owner: "dependency", index: 0, }, ]), ); expect(report.gradle).toBeNull(); expect(report.coverage.status).toBe("complete"); expect(report.limitations.join(" ")).toMatch( /without running Maven or Gradle/u, ); expect(report.limitations.join(" ")).toMatch(/parent POM was not read/u); }); it("reads Gradle component coordinates, variants, exclusions and platform constraints", () => { const report = parse(gradleModuleFixture, "/artifacts/demo-1.2.3.module"); expect(report.format).toBe("gradle-module"); expect(report.coordinates).toEqual({ group_id: "com.example", artifact_id: "demo", version: "1.2.3", packaging: null, }); expect(report.parent).toBeNull(); expect(report.gradle).toEqual({ format_version: "1.1", created_by_gradle: "8.10.2", variants: [ { name: "apiElements", category: "library", usage: "java-api", available_at: null, dependency_count: 1, constraint_count: 0, }, { name: "runtimeElements", category: "library", usage: "java-runtime", available_at: null, dependency_count: 0, constraint_count: 1, }, { name: "demoPlatform", category: "platform", usage: null, available_at: null, dependency_count: 0, constraint_count: 1, }, ], }); expect(report.dependencies).toEqual([ expect.objectContaining({ group_id: "com.fasterxml.jackson.core", artifact_id: "jackson-databind", version: "2.17.2", version_kind: "literal", origin: "variant-dependencies", variant: "apiElements", platform: false, exclusions: [ { group_id: "com.fasterxml.jackson.core", artifact_id: "jackson-annotations", }, ], gradle_version: { requires: "2.17.2", prefers: null, strictly: null, rejects: [], }, }), ]); expect(report.dependency_management).toEqual([ expect.objectContaining({ group_id: "org.slf4j", artifact_id: "slf4j-api", version: "2.0.16", origin: "variant-constraints", variant: "runtimeElements", platform: false, }), expect.objectContaining({ group_id: "com.fasterxml.jackson.core", artifact_id: "jackson-databind", version: "[2.17,2.18)", version_kind: "range", origin: "variant-constraints", variant: "demoPlatform", platform: true, gradle_version: { requires: null, prefers: null, strictly: "[2.17,2.18)", rejects: [], }, }), ]); expect(report.limitations.join(" ")).toMatch(/available-at coordinates/u); }); it("does not interpolate Maven properties into coordinates", () => { const report = parse(mavenPomFixture); expect(report.coordinates.version).toBe("${revision}"); expect(report.coordinates.version).not.toBe("1.2.3"); }); it("lists every property in a compound CI-friendly version", () => { const report = parse(` com.example demo \${revision}\${sha1}\${changelist} `); expect(report.coordinates.version).toBe("${revision}${sha1}${changelist}"); expect( report.unresolved.filter( (entry) => entry.owner === "project" && entry.field === "version", ), ).toEqual( ["${revision}", "${sha1}", "${changelist}"].map((reference) => ({ kind: "property", reference, field: "version", owner: "project", index: null, })), ); }); it("removes credentials from Gradle available-at URLs", () => { const report = parse( JSON.stringify({ formatVersion: "1.1", component: { group: "com.example", module: "demo", version: "1.0.0" }, variants: [ { name: "secret", "available-at": { url: "https://user:password@repo.example/demo-jvm/1.0.0/demo-jvm-1.0.0.module", group: "com.example", module: "demo-jvm", version: "1.0.0", }, }, { name: "relative", "available-at": { url: "../../demo-jvm/1.0.0/demo-jvm-1.0.0.module", group: "com.example", module: "demo-jvm", version: "1.0.0", }, }, ], }), "/artifacts/demo-1.0.0.module", ); const urls = report.gradle?.variants.map((variant) => ({ url: variant.available_at?.url, redacted: variant.available_at?.url_credentials_redacted, })); expect(urls).toEqual([ { url: "https://repo.example/demo-jvm/1.0.0/demo-jvm-1.0.0.module", redacted: true, }, { url: "../../demo-jvm/1.0.0/demo-jvm-1.0.0.module", redacted: false }, ]); expect(JSON.stringify(report)).not.toContain("password"); }); it("removes credentials from POM property values", () => { const report = parse(` 4.0.0 demo https://user:password@repo.example/maven https://repo.example/mirror user@example.com `); expect(report.properties).toEqual([ { name: "repo.url", value: "https://repo.example/maven", value_credentials_redacted: true, }, { name: "mirror.url", value: "https://repo.example/mirror", value_credentials_redacted: false, }, { name: "owner", value: "user@example.com", value_credentials_redacted: false, }, ]); expect(JSON.stringify(report)).not.toContain("password"); }); it("applies XML end-of-line handling to POM text", () => { const report = parse( "\r\n 4.0.0\r\n demo\r\n \r\n first\r\nsecond\rthird\r\n \r\n\r\n", ); expect(report.properties).toEqual([ { name: "banner", value: "first\nsecond\nthird", value_credentials_redacted: false, }, ]); }); it("lists properties in packaging, scope, type and classifier", () => { const report = parse(` com.example demo 1.0.0 \${artifact.packaging} com.example lib 1.0.0 \${lib.scope} \${lib.type} \${os}-\${arch} `); expect(report.unresolved).toEqual([ { kind: "property", reference: "${artifact.packaging}", field: "packaging", owner: "project", index: null, }, ...( [ ["scope", "${lib.scope}"], ["type", "${lib.type}"], ["classifier", "${os}"], ["classifier", "${arch}"], ] as const ).map(([field, reference]) => ({ kind: "property", reference, field, owner: "dependency", index: 0, })), ]); }); it.each([ ["]1.0,2.0]", "range"], ["[1.0,2.0[", "range"], ["(,2.0]", "range"], ["[1.0,)", "range"], ["[1.0]", "range"], ["[1.0\u00a0beta,2.0]", "range"], ["[1.0\u2003beta]", "range"], ["[1.0\tbeta,2.0]", "literal"], ["[\t1.0,\r\n2.0 ]", "range"], ["[\u00a01.0 ,2.0]", "range"], ["[1.0 \u00a0,2.0]", "literal"], ["1.+", "dynamic"], ["latest.release", "dynamic"], ["latest.release.candidate", "dynamic"], ["sdk[preview]", "literal"], ["[1.0,2.0", "literal"], ])("reports Gradle selector %s as %s", (requires, versionKind) => { const report = parse( JSON.stringify({ formatVersion: "1.1", component: { group: "com.example", module: "demo", version: "1.0.0" }, variants: [ { name: "apiElements", dependencies: [ { group: "com.example", module: "lib", version: { requires } }, ], }, ], }), "/artifacts/demo-1.0.0.module", ); expect(report.dependencies[0]).toMatchObject({ version: requires, version_kind: versionKind, }); }); it("keeps an empty relativePath and a property-spelled optional distinct from omission", () => { const report = parse(` com.example demo-parent 1.0.0 demo com.example declared 1.0.0 \${dep.optional} com.example omitted 1.0.0 `); expect(report.parent).toMatchObject({ relative_path: null, relative_path_declared: true, }); expect(report.dependencies).toEqual([ expect.objectContaining({ artifact_id: "declared", optional: null, optional_spelling: "${dep.optional}", }), expect.objectContaining({ artifact_id: "omitted", optional: null, optional_spelling: null, }), ]); expect(report.unresolved).toContainEqual({ kind: "property", reference: "${dep.optional}", field: "optional", owner: "dependency", index: 0, }); const omitted = parse(` com.example demo-parent 1.0.0 demo `); expect(omitted.parent).toMatchObject({ relative_path: null, relative_path_declared: false, }); }); it("records unread profiles without activating them", () => { const report = parse(` demo extra com.example hidden `); expect(report.dependencies).toEqual([]); expect(report.limitations.join(" ")).toMatch(/profiles are present/u); }); it("refuses malformed XML as invalid format", () => { expectFailure("demo", "malformed"); }); it("refuses a document type declaration", () => { expectFailure( `demo`, "unsupported", ); }); it("refuses XML that is not a Maven project", () => { expectFailure( "demo", "unsupported", ); }); it("refuses a POM with two top-level dependencies blocks", () => { expectFailure( ` demo com.example first 1.0.0 com.example second 2.0.0 `, "malformed", ); }); it("refuses a POM with two dependencies blocks inside dependencyManagement", () => { expectFailure( ` demo com.example first 1.0.0 com.example second 2.0.0 `, "malformed", ); }); it("refuses a POM dependency with two version children", () => { expectFailure( ` demo com.example lib 1.0.0 2.0.0 `, "malformed", ); }); it("refuses malformed Gradle JSON", () => { expectFailure("{", "malformed"); }); it("keeps malformed Gradle JSON source out of the failure message", () => { const bytes = Buffer.from('{\n "url": //user:secret@repo.example/x}', "utf8"); let failure: unknown; try { parseMavenGradleMetadata(bytes, { path: "/artifacts/demo.module", sha256: createHash("sha256").update(bytes).digest("hex"), bytes: bytes.length, }); } catch (cause) { failure = cause; } expect(failure).toBeInstanceOf(ParseFailureError); expect(failure).toMatchObject({ failure: { kind: "malformed" } }); const { message } = failure as ParseFailureError; expect(message).not.toContain("user:secret"); expect(message).not.toContain("repo.example"); expect(message).not.toContain('"url"'); }); it("refuses unreadable Gradle version and available-at values", () => { const module = (variant: Record) => JSON.stringify({ formatVersion: "1.1", component: { group: "com.example", module: "demo", version: "1.0.0" }, variants: [{ name: "runtime", ...variant }], }); const dependency = (version: unknown) => module({ dependencies: [{ group: "com.example", module: "lib", version }], }); expectFailure(dependency(42), "malformed"); expectFailure(dependency(null), "malformed"); expectFailure(dependency({ requires: 42 }), "malformed"); expectFailure(dependency({ strictly: ["1.0"] }), "malformed"); expectFailure(module({ "available-at": "demo-jvm" }), "malformed"); expectFailure(module({ "available-at": [] }), "malformed"); }); it("refuses Gradle metadata with a repeated field instead of keeping the last", () => { const source = `{"formatVersion":"1.1","component":{"group":"com.example","module":"demo","version":"1.0.0"},"variants":[{"name":"runtime","dependencies":[{"group":"com.example","module":"lib","version":{"requires":"1.0"}}],"dependencies":[]}]}`; expectFailure(source, "malformed"); const root = `{"formatVersion":"1.1","formatVersion":"1.1","component":{"group":"com.example","module":"demo","version":"1.0.0"},"variants":[]}`; expectFailure(root, "malformed"); }); it("keeps a repeated Gradle field name out of the failure message", () => { const source = `{"formatVersion":"1.1","https://user:secret@repo.example/x":1,"https://user:secret@repo.example/x":2,"component":{"group":"com.example","module":"demo","version":"1.0.0"},"variants":[]}`; const bytes = Buffer.from(source, "utf8"); let failure: unknown; try { parseMavenGradleMetadata(bytes, { path: "/artifacts/demo.module", sha256: createHash("sha256").update(bytes).digest("hex"), bytes: bytes.length, }); } catch (cause) { failure = cause; } expect(failure).toBeInstanceOf(ParseFailureError); expect(failure).toMatchObject({ failure: { kind: "malformed" } }); const { message } = failure as ParseFailureError; expect(message).not.toContain("user:secret"); expect(message).not.toContain("repo.example"); }); it("refuses JSON that is not Gradle module metadata", () => { expectFailure('{"name":"demo"}', "unsupported"); }); it("refuses empty and non-metadata files", () => { expectFailure("", "malformed"); expectFailure("not xml or json", "unsupported"); }); it("keeps coverage examined_bytes equal to the artifact length", () => { const report: MavenGradleMetadata = parse(mavenPomFixture); expect(report.coverage.examined_bytes).toBe(report.artifact.bytes); }); // A 1,000-character variant name on 5,000 dependency rows repeats 5,000,000 // characters, past the fixed allowance, from about 300 KB of input. const repeatedVariantModule = () => JSON.stringify({ formatVersion: "1.1", component: { group: "com.example", module: "demo", version: "1.0.0" }, variants: [ { name: "v".repeat(1000), dependencies: Array.from({ length: 5000 }, (_, index) => ({ group: "com.example", module: `lib${String(index)}`, version: { requires: "1.0" }, })), }, ], }); it("refuses Gradle metadata whose rows would repeat variant names past the report allowance", () => { const bytes = Buffer.from(repeatedVariantModule(), "utf8"); expect(() => parseMavenGradleMetadata(bytes, { path: "/artifacts/demo.module", sha256: createHash("sha256").update(bytes).digest("hex"), bytes: bytes.length, }), ).toThrow(ParseFailureError); }); it("reports the repeated variant-name refusal as a fixed report allowance", async () => { const root = await createTestTempDirectory("rea-gradle-report-"); const path = join(root, "demo.module"); await writeFile(path, repeatedVariantModule()); const provider = new MavenGradleMetadataProvider(); try { const result = await provider.inspect({ path, max_file_bytes: 1024 * 1024, }); expect(result.ok).toBe(false); if (result.ok) return; expect(projectAnalysisError(result.error)).toMatchObject({ code: "resource_constraint", retryable: false, remediation: { action: expect.stringContaining("fixed report allowance"), }, }); } finally { await provider.close(); } }); it("reads POM values written as CDATA and as mixed text and CDATA", () => { const report = parse(` 4.0.0 demo 1.3 `); expect(report.coordinates).toMatchObject({ group_id: "com.example", version: "1.2.3", }); expect(report.properties).toContainEqual({ name: "revision", value: "1.2.3", value_credentials_redacted: false, }); }); it.for([ ``, `demo`, ])("refuses a non-Maven project document %s as unsupported", (source) => { expectFailure(source, "unsupported"); }); const gradleModule = (variant: string) => `{"formatVersion":"1.1","component":{"group":"g","module":"m","version":"1"},"variants":[${variant}]}`; it.for([ gradleModule(`{"name":"v","dependencies":{"group":"a"}}`), gradleModule(`{"name":"v","dependencyConstraints":"none"}`), gradleModule(`{"name":"v","dependencies":[null]}`), gradleModule(`null`), `{"formatVersion":"1.1","component":{"group":"g","module":"m"},"variants":{}}`, gradleModule( `{"name":"v","dependencies":[{"group":"a","module":"b","version":{"requires":"1","rejects":"2"}}]}`, ), gradleModule( `{"name":"v","dependencies":[{"group":"a","module":"b","version":{"requires":"1","rejects":[2]}}]}`, ), gradleModule( `{"name":"v","dependencies":[{"group":"a","module":"b","excludes":{"group":"x"}}]}`, ), gradleModule( `{"name":"v","dependencies":[{"group":"a","module":"b","excludes":["x"]}]}`, ), ])( "refuses Gradle metadata with an unreadable present collection %s", (source) => { expectFailure(source, "malformed"); }, ); it("reads Gradle version rejects and dependency exclusions", () => { const report = parse( gradleModule( `{"name":"v","dependencies":[{"group":"a","module":"b","version":{"requires":"1","rejects":["2"]},"excludes":[{"group":"x","module":"y"}]}]}`, ), ); expect(report.dependencies).toEqual([ expect.objectContaining({ exclusions: [{ group_id: "x", artifact_id: "y" }], gradle_version: expect.objectContaining({ rejects: ["2"] }), }), ]); }); it.for([ [ "Gradle", gradleModule( `{"name":"v","dependencies":[${Array(65_537).fill("{}").join(",")}]}`, ), ], [ "POM", `demo${"".repeat(65_537)}`, ], ] as const)( "refuses %s rows past the report allowance before building them", ([, source]) => { const bytes = Buffer.from(source, "utf8"); let failure: unknown; try { parseMavenGradleMetadata(bytes, { path: "/artifacts/selected", sha256: createHash("sha256").update(bytes).digest("hex"), bytes: bytes.length, }); } catch (cause) { failure = cause; } expect(failure).toBeInstanceOf(ParseFailureError); expect(failure).toMatchObject({ failure: { kind: "limit", limit: { name: "dependency_rows", maximum: 65_536, required: 65_537 }, }, }); }, ); it.for([ [ "Gradle variants", `{"formatVersion":"1.1","variants":[${Array(4_097).fill("{}").join(",")}]}`, { allowance: "variants", limit: 4_096, required: 4_097 }, ], [ "Gradle exclusions", gradleModule( `{"name":"v","dependencies":[{"group":"a","module":"b","excludes":[${Array(65_537).fill("{}").join(",")}]}]}`, ), { allowance: "exclusions", limit: 65_536, required: 65_537 }, ], [ "POM exclusions", `demo${"".repeat(65_537)}`, { allowance: "exclusions", limit: 65_536, required: 65_537 }, ], ] as const)( "refuses %s past the report allowance before building them", ([, source, expected]) => { const bytes = Buffer.from(source, "utf8"); let failure: unknown; try { parseMavenGradleMetadata(bytes, { path: "/artifacts/selected", sha256: createHash("sha256").update(bytes).digest("hex"), bytes: bytes.length, }); } catch (cause) { failure = cause; } expect(failure).toBeInstanceOf(ParseFailureError); expect(failure).toMatchObject({ failure: { kind: "limit", limit: { name: expected.allowance, maximum: expected.limit, required: expected.required, }, }, }); }, ); it("reports the variant refusal as a fixed report allowance", async () => { const root = await createTestTempDirectory("rea-gradle-variants-"); const path = join(root, "demo.module"); await writeFile( path, `{"formatVersion":"1.1","variants":[${Array(4_097).fill("{}").join(",")}]}`, ); const provider = new MavenGradleMetadataProvider(); try { const result = await provider.inspect({ path, max_file_bytes: 1024 * 1024, }); expect(result.ok).toBe(false); if (result.ok) return; expect(projectAnalysisError(result.error)).toMatchObject({ code: "resource_constraint", retryable: false, remediation: { action: expect.stringContaining("4096-variant allowance"), }, }); } finally { await provider.close(); } }); it("refuses a POM past the XML node allowance before building its tree", () => { const source = `demo${"

".repeat(1_048_577)}`; const bytes = Buffer.from(source, "utf8"); let failure: unknown; try { parseMavenGradleMetadata(bytes, { path: "/artifacts/selected", sha256: createHash("sha256").update(bytes).digest("hex"), bytes: bytes.length, }); } catch (cause) { failure = cause; } expect(failure).toBeInstanceOf(ParseFailureError); expect(failure).toMatchObject({ failure: { kind: "limit", limit: { name: "xml_nodes", maximum: 1_048_576, required: 1_048_577 }, }, }); }); it.each([ ["gradle-module", gradleModuleFixture, "/artifacts/demo.module"], ["maven-pom", mavenPomFixture, "/artifacts/pom.xml"], ] as const)( "reads %s with a UTF-8 signature and retains the input identity", (format, source, path) => { const signed = "\ufeff" + source; const report = parse(signed, path); const original = parse(source, path); expect(report).toEqual({ ...original, artifact: { path, bytes: Buffer.byteLength(signed), sha256: createHash("sha256").update(signed, "utf8").digest("hex"), }, coverage: { ...original.coverage, examined_bytes: Buffer.byteLength(signed), }, }); expect(report.format).toBe(format); }, ); it("still rejects duplicate fields after a Gradle UTF-8 signature", () => { expect(() => parse('\ufeff{"formatVersion":"1.1","formatVersion":"1.1"}'), ).toThrow(/declares a field more than once/u); });