Compare commits

...
Author SHA1 Message Date
Anthony Stirling 318aa054da Merge remote-tracking branch 'origin/main' into work-6411 2026-05-26 19:12:09 +01:00
Anthony Stirling 3fb94dde64 Broaden jpdfium temp-file exclusion in regression check 2026-05-22 16:49:14 +01:00
Anthony Stirling 6ed67c41d4 Bump JPDFium dep to 1.0.1 2026-05-22 16:27:22 +01:00
Anthony Stirling 8bffa536fe Revert SanitizeControllerTest and re-apply spotless format 2026-05-22 13:58:46 +01:00
Anthony Stirling 5acaa487fd Merge remote-tracking branch 'origin/main' into feat/jpdfium-sanitize-js-sigs 2026-05-22 13:57:19 +01:00
Anthony Stirling bcbdd8d537 Merge remote-tracking branch 'origin/main' into feat/jpdfium-sanitize-js-sigs
# Conflicts:
#	frontend/scripts/sign-jpdfium-dylibs-in-bootjar.sh
2026-05-22 13:24:37 +01:00
Anthony Stirling 2de02ba145 impl migration to pdfium for sanitize and javascript and certsign 2026-05-22 09:54:42 +01:00
Anthony Stirling 2f1fe2c80c Delete MergeBenchmark 2026-05-21 23:00:00 +01:00
Anthony Stirling 1051f28c52 Drop remaining why/how comments 2026-05-21 19:11:52 +01:00
Anthony Stirling 29ccbf7ae6 Trim verbose comments across JPDFium integration 2026-05-21 19:03:31 +01:00
Anthony Stirling 007c8e17de Exclude JPDFium native cache from temp-file regression check 2026-05-21 17:46:46 +01:00
Anthony Stirling 81dbb29be3 Iterative addBookmarkFlat with depth + cycle + node-count guards 2026-05-21 17:17:06 +01:00
Anthony Stirling caef0477a9 Merge remote-tracking branch 'origin/main' into feat/jpdfium-integration
# Conflicts:
#	app/common/build.gradle
2026-05-21 16:55:18 +01:00
Anthony Stirling 7682a0dd54 sign-jpdfium-dylibs: sign both Gradle and Tauri bootJar copies 2026-05-21 16:26:52 +01:00
Anthony Stirling f90ed4657a Apply spotless; bash 3.2-compatible array handling in sign-jpdfium-dylibs 2026-05-21 15:53:28 +01:00
Anthony Stirling a6c7a68242 Move sign-jpdfium-dylibs-in-bootjar.sh into frontend/scripts/ 2026-05-21 15:21:25 +01:00
Anthony Stirling a184b394d6 Strip rationale-history comments from JDK 25 references 2026-05-21 15:20:11 +01:00
Anthony Stirling 302d04c201 Merge remote-tracking branch 'origin/main' into feat/jpdfium-integration
# Conflicts:
#	build.gradle
2026-05-21 15:05:51 +01:00
Anthony Stirling 68ae9d52fb Bump JPDFium dep to 1.0.0; drop snapshot repo 2026-05-21 14:46:10 +01:00
Anthony Stirling 6552ba905c Cleanup: drop local mavenLocal hack; gate MergeBenchmark with -Dmerge.bench=true 2026-05-21 11:58:43 +01:00
Anthony Stirling ee36b6f616 MergeController: preserve source bookmarks through merge (PDFium drops them) 2026-05-21 11:39:59 +01:00
Anthony Stirling 627091f8df MergeController: use JPDFium native merge (94% less heap on 5-doc merge) 2026-05-21 10:37:01 +01:00
Anthony Stirling 67a37d3291 Filter JPDFium natives per Tauri target OS (saves ~45 MB per bundle) 2026-05-21 00:28:31 +01:00
Anthony Stirling 4b6d4885f4 sign-jpdfium-dylibs: resolve native-jar paths via jar tf first
`jar xf <jar> <path>` doesn't expand glob patterns in <path> the way
`unzip` does — paths must be exact. My initial script passed
`BOOT-INF/lib/jpdfium-natives-darwin-x64-*.jar` as a literal path,
which matched nothing, so the script always reported
"No JPDFium darwin natives in bootJar; nothing to sign" and exited
without actually signing anything.

Fix: `jar tf` to LIST the bootJar's contents, grep with a regex for
the snapshot-versioned native-jar paths, then `jar xf` those exact
paths.

The natives jars are normally:
  BOOT-INF/lib/jpdfium-natives-darwin-x64-1.0.0-SNAPSHOT.jar
  BOOT-INF/lib/jpdfium-natives-darwin-arm64-1.0.0-SNAPSHOT.jar
…but the version number floats with the snapshot timestamp, hence
the regex match instead of a fixed path.
2026-05-20 09:46:07 +01:00
Anthony Stirling 2a151b65f7 Move JPDFium dylib signing step AFTER cert import
My first placement put the sign-jpdfium-dylibs-in-bootjar step at
the wrong point in the workflow: BEFORE the "Verify Certificate"
step that sets APPLE_SIGNING_IDENTITY in GITHUB_ENV. So the gate
`if: ... && env.APPLE_SIGNING_IDENTITY != ''` always evaluated to
false and the step silently skipped, leaving the dylibs unsigned
and notarytool still rejecting the .app.

Move it to right after Verify Certificate (which sets the env var
from the keychain identity). Also switch the gate to checking
env.APPLE_CERTIFICATE (the secret that's set at job level and
available from step 1) rather than env.APPLE_SIGNING_IDENTITY (set
mid-workflow via GITHUB_ENV) — the latter is fine in `run:` blocks
but flaky in `if:` evaluation depending on GH Actions evaluation
timing.
2026-05-20 09:08:37 +01:00
Anthony Stirling 9458fcd0e2 Re-run CI against JPDFium with Windows ICU trim + harfbuzz-no-glib 2026-05-20 00:45:22 +01:00
Anthony Stirling 1e8c41425b Sign JPDFium dylibs in bootJar before Tauri notarization (macOS)
Tauri-build macos-universal has been failing notarytool because the
.dylib files inside the JPDFium native jars (jpdfium-natives-darwin-
x64-*.jar / -arm64-*.jar) ship unsigned — JPDFium's publish workflow
has no Apple Developer credentials, so it can't sign during publish.
Apple's notarytool walks INTO nested .jars in the .app and reports:

  "The binary is not signed."
  path: Stirling-PDF.zip/Stirling-PDF.app/Contents/Resources/libs/
   stirling-pdf-*.jar/BOOT-INF/lib/
   jpdfium-natives-darwin-x64-1.0.0-SNAPSHOT.jar/natives/darwin-x64/
   libjpdfium.dylib

Tauri's own codesign walk doesn't open .jars, so the fix has to
happen here before tauri-action runs. New step between
`task desktop:prepare` (builds bootJar) and `tauri-action` (builds
.app + notarizes):

  scripts/sign-jpdfium-dylibs-in-bootjar.sh
    1. jar xf bootJar BOOT-INF/lib/jpdfium-natives-darwin-*.jar
    2. for each native jar, explode it, codesign every .dylib with
       APPLE_SIGNING_IDENTITY + --options runtime + --timestamp
    3. jar cfM0 to repack the natives jar (stored, no deflate —
       matches Spring Boot's preferred layout)
    4. jar uf bootJar to replace the natives jars in the outer
       bootJar with the freshly-signed versions

Gated on macOS-15 + APPLE_SIGNING_IDENTITY being set, so PR builds
from forks (no secret) fall through and the existing
"binary not signed" failure persists — no regression vs current.
2026-05-19 23:32:09 +01:00
Anthony Stirling b3277a18c8 Re-run CI: pick up Rust-LTO-trimmed JPDFium snapshot 2026-05-19 18:56:29 +01:00
Anthony Stirling 5ca1586976 Re-run CI: pick up smaller (ICU+qpdf trim) JPDFium snapshot 2026-05-19 18:18:21 +01:00
Anthony Stirling ce47a4e3af Re-run CI: pick up ICU-trimmed JPDFium snapshot 2026-05-19 17:08:17 +01:00
Anthony Stirling 859a2d97c2 Always re-resolve JPDFium snapshots in CI
PR rerun against new JPDFium snapshots kept using Gradle's cached
versions from earlier runs. Gradle caches 'changing modules' (anything
ending in -SNAPSHOT) for 24h by default, and gh run rerun --failed
reuses the existing run's Gradle home — so even after publishing a
fresh com.stirling:jpdfium-natives-*:1.0.0-SNAPSHOT, the bootJar kept
embedding the old natives.

cacheChangingModulesFor 0 means every Gradle invocation re-checks the
snapshot's maven-metadata.xml and pulls a newer timestamped build if
present. cacheDynamicVersionsFor 0 does the same for non-snapshot
dynamic versions (e.g. '1.+'). Both are scoped to the
subprojects.configurations.all block alongside the existing security
force-versions.

Trade-off: every Gradle invocation in CI does a HEAD against Maven
Central per snapshot dep (4 natives + 1 main jpdfium = 5 small
requests). Negligible compared to a download. Reverts naturally when
JPDFium ships a tagged release.
2026-05-19 15:00:02 +01:00
Anthony Stirling a422deecdb Re-add jpdfium-natives-darwin-x64 (Intel Mac) runtime dep
The publish-github-packages workflow's restored darwin-x64 build now
cross-compiles from macos-14 under Rosetta + a second Homebrew, so the
natives jar is available again. Adding it back to the bootJar classpath
lets the tauri-build macos-15 universal binary cover Intel Macs too.
2026-05-19 10:15:16 +01:00
Anthony Stirling 7f8f09c899 Native-access via bootJar manifest, not CLI flags everywhere
JDK 22+ honors an 'Enable-Native-Access' attribute on the executable
jar's manifest (JEP 472). Setting it once on the Spring Boot bootJar
removes the need to remember --enable-native-access=ALL-UNNAMED in:
  - Docker init script's JAVA_BASE_OPTS injection
  - Tauri Rust launcher's java_options vector
  - Anywhere else somebody runs the bootJar
…and also future-proofs against JDK 26's hard-fail behavior without
each launch point having to track the flag.

app/core/build.gradle: add 'Enable-Native-Access': 'ALL-UNNAMED' to the
bootJar manifest attributes block.

build.gradle (bootRun jvmArgs): keep --enable-native-access=ALL-UNNAMED
because bootRun launches from classfiles, not the bootJar — the
manifest mechanism doesn't apply to that codepath, only to 'java -jar'.

scripts/init-without-ocr.sh: drop the FFM injection.
frontend/src-tauri/src/commands/backend.rs: drop the CLI arg.
2026-05-18 21:35:06 +01:00
Anthony Stirling 96920b1186 build.gradle: modernJavaVersion 21 -> 25
This was the actual culprit behind 'JVM runtime version 21 vs 25' Gradle
variant-attribute mismatch errors during PR CI. modernJavaVersion drives:
- options.release on JavaCompile.configureEach across all subprojects
- restart-helper compile target

Even though sourceCompatibility / targetCompatibility were already bumped
to VERSION_25 in an earlier commit, --release 21 on javac overrode them
and made Gradle's compileClasspath declare org.gradle.jvm.version=21,
which then refused to resolve com.stirling:jpdfium:1.0.0-SNAPSHOT
(published as JVM 25).

Bumping modernJavaVersion to 25 aligns everything.
2026-05-18 19:09:28 +01:00
Anthony Stirling 3626319685 docs+ci: scrub remaining JDK 21 references
JPDFium's published artifacts target JVM 25 and Stirling-PDF's main
sources are now compiled with sourceCompatibility = VERSION_25, so JDK
21 is no longer supported. Update header comments and developer-facing
docs to reflect the hard floor.

- backend-build.yml header: 'JDK 21/25 \xc3\x97 spring-security' -> 'JDK 25 \xc3\x97 spring-security'
- AGENTS.md Important Notes: minimum 21 -> requires 25
- DeveloperGuide.md prerequisites + setup steps: drop 'or later, 25 recommended'
  language, say 'JDK 25' outright.
2026-05-18 19:07:11 +01:00
Anthony Stirling 755f270a31 ci: drop JDK 21 from backend build matrix
JPDFium's published artifacts carry org.gradle.jvm.version=25 (FFM is
finalized at JDK 22+; JPDFium picks 25 as the source target). Gradle's
variant attribute matching refuses to resolve the dep on JDK 21
targets, so the 21 cells in this matrix were guaranteed to fail.

Now that targetCompatibility is bumped to 25 across the project, JDK 25
is the only supported toolchain.
2026-05-18 19:04:59 +01:00
Anthony Stirling 6e1a7454ca Integrate Stirling-Tools JPDFium for PDF operations
This is a bring-up branch to validate JPDFium consumption across all
Stirling-PDF release targets (server jar, Docker, Tauri desktop). Open
as PR for cross-platform CI validation.

Source dep
- com.stirling:jpdfium:1.0.0-SNAPSHOT  (pulled from Maven Central snapshots,
  fully anonymous — no PAT or GitHub Packages auth needed)
- Per-platform natives: linux-x64, linux-arm64, darwin-arm64, windows-x64
  All four are added as runtimeOnly so the bootJar carries every platform
  and NativeLoader picks the right one at startup. The natives jars are
  hermetic — each bundles its bridge, PDFium component libs, and the
  third-party deps (pcre2/freetype/harfbuzz/icu/qpdf/pugixml/libunibreak),
  so no system package install is required at runtime.
- TODO follow-up: jpdfium-natives-darwin-x64 (Intel Mac) — dropped from
  the upstream publish matrix while cross-compile-on-macos-14 setup lands.

JDK 25 enforcement
- Bump root + subprojects from sourceCompatibility / targetCompatibility
  21 -> 25. JPDFium publishes with org.gradle.jvm.version=25 (FFM is final
  in JDK 22+; JPDFium picks 25 as the floor), and a 21-targeted Stirling-PDF
  jar would fail Gradle's variant attribute match at compile time.
- bootRun jvmArgs: add --enable-native-access=ALL-UNNAMED. JDK 25 warns
  on restricted FFM methods without it; JDK 26 will hard-fail.

Docker
- scripts/init-without-ocr.sh: prepend --enable-native-access=ALL-UNNAMED
  to JAVA_BASE_OPTS so the JAVA_TOOL_OPTIONS env var that the container
  sets includes it for the running JVM. Idempotent — won't duplicate if
  already present.

Tauri
- frontend/src-tauri/src/commands/backend.rs: the sidecar Java spawn now
  passes --enable-native-access=ALL-UNNAMED. The bundled jlink JRE's
  module list (desktop.yml JLINK_MODULES) already includes java.desktop
  and java.net.http which is everything JPDFium's module-info requires.

Smoke test
- app/common/src/test/java/stirling/software/common/jpdfium/JPDFiumSmokeTest.java
  Opens the existing common test resource example.pdf via PdfDocument.open
  and asserts a positive page count. Confirms the dep resolves, the right
  natives jar lands on the classpath, the bridge + PDFium component libs
  + third-party deps all load, and the FFM bindings parse a real PDF
  end-to-end. Runs as part of :common:test on each platform's CI runner.
2026-05-18 18:31:37 +01:00
4 changed files with 420 additions and 451 deletions
@@ -1,7 +1,10 @@
package stirling.software.SPDF.controller.api.misc;
import java.io.File;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.util.List;
import java.util.Map;
import org.apache.pdfbox.pdmodel.PDDocument;
@@ -17,6 +20,7 @@ import io.github.pixee.security.Filenames;
import io.swagger.v3.oas.annotations.Operation;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import stirling.software.SPDF.config.swagger.JavaScriptResponse;
import stirling.software.common.annotations.AutoJobPostMapping;
@@ -27,8 +31,12 @@ import stirling.software.common.service.CustomPDFDocumentFactory;
import stirling.software.common.util.TempFile;
import stirling.software.common.util.TempFileManager;
import stirling.software.common.util.WebResponseUtils;
import stirling.software.jpdfium.PdfDocument;
import stirling.software.jpdfium.doc.JsAction;
import stirling.software.jpdfium.doc.PdfJavaScriptInspector;
@MiscApi
@Slf4j
@RequiredArgsConstructor
public class ShowJavascript {
@@ -45,60 +53,88 @@ public class ShowJavascript {
description = "desc. Input:PDF Output:JS Type:SISO")
public ResponseEntity<Resource> extractHeader(@ModelAttribute PDFFile file) throws Exception {
MultipartFile inputFile = file.getFileInput();
String simpleFilename = Filenames.toSimpleFileName(inputFile.getOriginalFilename());
StringBuilder script = new StringBuilder();
boolean foundScript = false;
try (PDDocument document = pdfDocumentFactory.load(inputFile)) {
// JPDFium fast path: read document-level JS without PDFBox roundtrip.
File tempPdf = tempFileManager.convertMultipartFileToFile(inputFile);
boolean jpdfiumOk = false;
try {
try (PdfDocument doc = PdfDocument.open(tempPdf.toPath())) {
List<JsAction> docScripts = PdfJavaScriptInspector.documentScripts(doc.rawHandle());
for (JsAction action : docScripts) {
String code = action.script();
if (code != null && !code.trim().isEmpty()) {
appendScript(script, simpleFilename, action.name(), code);
foundScript = true;
}
}
jpdfiumOk = true;
} catch (Exception e) {
log.debug("JPDFium JS read failed, falling back to PDFBox: {}", e.getMessage());
}
if (!jpdfiumOk) {
foundScript = extractViaPdfBox(inputFile, simpleFilename, script);
}
} finally {
tempFileManager.deleteTempFile(tempPdf);
}
if (!foundScript) {
script =
new StringBuilder("PDF '")
.append(simpleFilename)
.append("' does not contain Javascript");
}
TempFile tempOut = tempFileManager.createManagedTempFile(".js");
try {
Files.write(
tempOut.getFile().toPath(), script.toString().getBytes(StandardCharsets.UTF_8));
} catch (Exception e) {
tempOut.close();
throw e;
}
return WebResponseUtils.fileToWebResponse(
tempOut, simpleFilename + ".js", MediaType.TEXT_PLAIN);
}
private static void appendScript(
StringBuilder script, String filename, String name, String code) {
script.append("// File: ")
.append(filename)
.append(", Script: ")
.append(name)
.append("\n")
.append(code)
.append("\n");
}
private boolean extractViaPdfBox(
MultipartFile inputFile, String simpleFilename, StringBuilder script)
throws IOException {
boolean foundScript = false;
try (PDDocument document = pdfDocumentFactory.load(inputFile)) {
if (document.getDocumentCatalog() != null
&& document.getDocumentCatalog().getNames() != null) {
PDNameTreeNode<PDActionJavaScript> jsTree =
document.getDocumentCatalog().getNames().getJavaScript();
if (jsTree != null) {
Map<String, PDActionJavaScript> jsEntries = jsTree.getNames();
for (Map.Entry<String, PDActionJavaScript> entry : jsEntries.entrySet()) {
String name = entry.getKey();
PDActionJavaScript jsAction = entry.getValue();
String jsCodeStr = jsAction.getAction();
if (jsCodeStr != null && !jsCodeStr.trim().isEmpty()) {
script.append("// File: ")
.append(
Filenames.toSimpleFileName(
inputFile.getOriginalFilename()))
.append(", Script: ")
.append(name)
.append("\n")
.append(jsCodeStr)
.append("\n");
appendScript(script, simpleFilename, name, jsCodeStr);
foundScript = true;
}
}
}
}
if (!foundScript) {
script =
new StringBuilder("PDF '")
.append(Filenames.toSimpleFileName(inputFile.getOriginalFilename()))
.append("' does not contain Javascript");
}
TempFile tempOut = tempFileManager.createManagedTempFile(".js");
try {
Files.write(
tempOut.getFile().toPath(),
script.toString().getBytes(StandardCharsets.UTF_8));
} catch (Exception e) {
tempOut.close();
throw e;
}
return WebResponseUtils.fileToWebResponse(
tempOut,
Filenames.toSimpleFileName(inputFile.getOriginalFilename()) + ".js",
MediaType.TEXT_PLAIN);
}
return foundScript;
}
}
@@ -1,5 +1,8 @@
package stirling.software.SPDF.controller.api.security;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.StandardCopyOption;
import java.util.List;
import org.apache.pdfbox.pdmodel.PDDocument;
@@ -16,6 +19,7 @@ import org.springframework.web.multipart.MultipartFile;
import io.swagger.v3.oas.annotations.Operation;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import stirling.software.SPDF.config.swagger.StandardPdfResponse;
import stirling.software.common.annotations.AutoJobPostMapping;
@@ -24,10 +28,13 @@ import stirling.software.common.enumeration.ResourceWeight;
import stirling.software.common.model.api.PDFFile;
import stirling.software.common.service.CustomPDFDocumentFactory;
import stirling.software.common.util.GeneralUtils;
import stirling.software.common.util.TempFile;
import stirling.software.common.util.TempFileManager;
import stirling.software.common.util.WebResponseUtils;
import stirling.software.jpdfium.PdfDocument;
@SecurityApi
@Slf4j
@RequiredArgsConstructor
public class RemoveCertSignController {
@@ -47,31 +54,53 @@ public class RemoveCertSignController {
public ResponseEntity<Resource> removeCertSignPDF(@ModelAttribute PDFFile request)
throws Exception {
MultipartFile pdf = request.getFileInput();
String outName = GeneralUtils.generateFilename(pdf.getOriginalFilename(), "_unsigned.pdf");
// Load the PDF document with proper resource management
try (PDDocument document = pdfDocumentFactory.load(pdf)) {
// Get the document catalog
PDDocumentCatalog catalog = document.getDocumentCatalog();
// Get the AcroForm
PDAcroForm acroForm = catalog.getAcroForm();
if (acroForm != null) {
// Remove signature fields safely
List<PDField> fieldsToRemove =
acroForm.getFields().stream()
.filter(field -> field instanceof PDSignatureField)
.toList();
if (!fieldsToRemove.isEmpty()) {
acroForm.flatten(fieldsToRemove, false);
File inputTempFile = tempFileManager.convertMultipartFileToFile(pdf);
try {
if (!needsSignatureFlatten(inputTempFile)) {
log.info("No signature fields detected; returning input as-is.");
TempFile passthrough = tempFileManager.createManagedTempFile(".pdf");
try {
Files.copy(
inputTempFile.toPath(),
passthrough.getFile().toPath(),
StandardCopyOption.REPLACE_EXISTING);
} catch (Exception e) {
passthrough.close();
throw e;
}
return WebResponseUtils.pdfFileToWebResponse(passthrough, outName);
}
// Return the modified PDF as a response
return WebResponseUtils.pdfDocToWebResponse(
document,
GeneralUtils.generateFilename(pdf.getOriginalFilename(), "_unsigned.pdf"),
tempFileManager);
// PDFBox flattens the /Sig field - JPDFium can read signatures but not strip them.
try (PDDocument document = pdfDocumentFactory.load(inputTempFile)) {
PDDocumentCatalog catalog = document.getDocumentCatalog();
PDAcroForm acroForm = catalog.getAcroForm();
if (acroForm != null) {
List<PDField> fieldsToRemove =
acroForm.getFields().stream()
.filter(field -> field instanceof PDSignatureField)
.toList();
if (!fieldsToRemove.isEmpty()) {
acroForm.flatten(fieldsToRemove, false);
}
}
return WebResponseUtils.pdfDocToWebResponse(document, outName, tempFileManager);
}
} finally {
tempFileManager.deleteTempFile(inputTempFile);
}
}
private boolean needsSignatureFlatten(File inputFile) {
try (PdfDocument check = PdfDocument.open(inputFile.toPath())) {
return !check.signatures().isEmpty();
} catch (Exception e) {
log.debug(
"JPDFium signature pre-check failed; falling back to PDFBox flatten: {}",
e.getMessage());
return true;
}
}
}
@@ -1,228 +1,180 @@
package stirling.software.SPDF.controller.api.misc;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.*;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.lenient;
import java.io.File;
import java.nio.file.Files;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.nio.file.Path;
import org.apache.pdfbox.Loader;
import org.apache.pdfbox.cos.COSDictionary;
import org.apache.pdfbox.cos.COSName;
import org.apache.pdfbox.cos.COSString;
import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.pdmodel.PDDocumentCatalog;
import org.apache.pdfbox.pdmodel.PDDocumentNameDictionary;
import org.apache.pdfbox.pdmodel.PDJavascriptNameTreeNode;
import org.apache.pdfbox.pdmodel.PDPage;
import org.apache.pdfbox.pdmodel.interactive.action.PDActionJavaScript;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.junit.jupiter.api.io.TempDir;
import org.mockito.Mock;
import org.mockito.MockedStatic;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.core.io.ByteArrayResource;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
import org.springframework.core.io.Resource;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.mock.web.MockMultipartFile;
import org.springframework.web.multipart.MultipartFile;
import stirling.software.common.model.ApplicationProperties;
import stirling.software.common.model.api.PDFFile;
import stirling.software.common.service.CustomPDFDocumentFactory;
import stirling.software.common.util.TempFile;
import stirling.software.common.util.TempFileManager;
import stirling.software.common.util.WebResponseUtils;
import stirling.software.common.util.TempFileRegistry;
@DisplayName("ShowJavascript Tests")
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
class ShowJavascriptTest {
private static ResponseEntity<Resource> streamingOk(byte[] bytes) {
return ResponseEntity.ok(new ByteArrayResource(bytes));
@Mock private CustomPDFDocumentFactory pdfDocumentFactory;
private TempFileManager tempFileManager;
private ShowJavascript controller;
@TempDir Path tempDir;
@BeforeEach
void setUp() throws IOException {
TempFileRegistry registry = new TempFileRegistry();
ApplicationProperties applicationProperties = new ApplicationProperties();
applicationProperties.getSystem().getTempFileManagement().setBaseTmpDir(tempDir.toString());
applicationProperties.getSystem().getTempFileManagement().setPrefix("showjs-test-");
tempFileManager = new TempFileManager(registry, applicationProperties);
controller = new ShowJavascript(pdfDocumentFactory, tempFileManager);
lenient()
.when(pdfDocumentFactory.load(any(MultipartFile.class)))
.thenAnswer(inv -> Loader.loadPDF(((MultipartFile) inv.getArgument(0)).getBytes()));
}
private static byte[] drainBody(ResponseEntity<Resource> response) throws java.io.IOException {
java.io.ByteArrayOutputStream baos = new java.io.ByteArrayOutputStream();
try (java.io.InputStream __in = response.getBody().getInputStream()) {
__in.transferTo(baos);
private static byte[] drainBody(ResponseEntity<Resource> response) throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try (InputStream in = response.getBody().getInputStream()) {
in.transferTo(baos);
}
return baos.toByteArray();
}
@Mock private CustomPDFDocumentFactory pdfDocumentFactory;
@Mock private TempFileManager tempFileManager;
@InjectMocks private ShowJavascript showJavascript;
private MockMultipartFile pdfFile;
private PDFFile request;
@BeforeEach
void setUp() throws Exception {
lenient()
.when(tempFileManager.createManagedTempFile(anyString()))
.thenAnswer(
inv -> {
File f =
Files.createTempFile("test", inv.<String>getArgument(0))
.toFile();
TempFile tf = mock(TempFile.class);
lenient().when(tf.getFile()).thenReturn(f);
lenient().when(tf.getPath()).thenReturn(f.toPath());
return tf;
});
pdfFile =
new MockMultipartFile(
"fileInput",
"test.pdf",
MediaType.APPLICATION_PDF_VALUE,
"PDF content".getBytes());
request = new PDFFile();
request.setFileInput(pdfFile);
private static MockMultipartFile multipart(String filename, byte[] data) {
return new MockMultipartFile("fileInput", filename, MediaType.APPLICATION_PDF_VALUE, data);
}
@Test
void extractHeader_noJavascript_returnsMessage() throws Exception {
PDDocument mockDoc = mock(PDDocument.class);
PDDocumentCatalog catalog = mock(PDDocumentCatalog.class);
when(mockDoc.getDocumentCatalog()).thenReturn(catalog);
when(catalog.getNames()).thenReturn(null);
when(pdfDocumentFactory.load(pdfFile)).thenReturn(mockDoc);
private static byte[] pdfWithoutJs() throws IOException {
try (PDDocument doc = new PDDocument()) {
doc.addPage(new PDPage());
ByteArrayOutputStream baos = new ByteArrayOutputStream();
doc.save(baos);
return baos.toByteArray();
}
}
try (MockedStatic<WebResponseUtils> mockedWebResponse =
mockStatic(WebResponseUtils.class)) {
ResponseEntity<Resource> expectedResponse = streamingOk("no js".getBytes());
mockedWebResponse
.when(
() ->
WebResponseUtils.fileToWebResponse(
any(TempFile.class),
eq("test.pdf.js"),
eq(MediaType.TEXT_PLAIN)))
.thenReturn(expectedResponse);
ResponseEntity<Resource> response = showJavascript.extractHeader(request);
assertNotNull(response);
assertEquals(HttpStatus.OK, response.getStatusCode());
mockedWebResponse.verify(
() ->
WebResponseUtils.fileToWebResponse(
any(TempFile.class),
eq("test.pdf.js"),
eq(MediaType.TEXT_PLAIN)));
private static byte[] pdfWithNameTreeJs(String name, String script) throws IOException {
try (PDDocument doc = new PDDocument()) {
doc.addPage(new PDPage());
PDDocumentNameDictionary names = new PDDocumentNameDictionary(doc.getDocumentCatalog());
PDJavascriptNameTreeNode jsTree = new PDJavascriptNameTreeNode();
// Build name tree with single entry via COSDictionary
COSDictionary kid = new COSDictionary();
org.apache.pdfbox.cos.COSArray nameArr = new org.apache.pdfbox.cos.COSArray();
nameArr.add(new COSString(name));
PDActionJavaScript jsAction = new PDActionJavaScript(script);
nameArr.add(jsAction.getCOSObject());
kid.setItem(COSName.NAMES, nameArr);
jsTree.getCOSObject().setItem(COSName.NAMES, nameArr);
names.getCOSObject().setItem(COSName.getPDFName("JavaScript"), jsTree.getCOSObject());
doc.getDocumentCatalog().setNames(names);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
doc.save(baos);
return baos.toByteArray();
}
}
@Test
void extractHeader_withJavascript_returnsScript() throws Exception {
PDDocument mockDoc = mock(PDDocument.class);
PDDocumentCatalog catalog = mock(PDDocumentCatalog.class);
PDDocumentNameDictionary nameDict = mock(PDDocumentNameDictionary.class);
PDJavascriptNameTreeNode jsTree = mock(PDJavascriptNameTreeNode.class);
@DisplayName("PDF with no JS returns 'does not contain Javascript' message")
void noJavascript_returnsMessage() throws Exception {
byte[] in = pdfWithoutJs();
PDFFile req = new PDFFile();
req.setFileInput(multipart("test.pdf", in));
PDActionJavaScript jsAction = mock(PDActionJavaScript.class);
when(jsAction.getAction()).thenReturn("alert('hello');");
ResponseEntity<Resource> resp = controller.extractHeader(req);
assertEquals(HttpStatus.OK, resp.getStatusCode());
when(mockDoc.getDocumentCatalog()).thenReturn(catalog);
when(catalog.getNames()).thenReturn(nameDict);
doReturn(jsTree).when(nameDict).getJavaScript();
java.util.Map<String, PDActionJavaScript> jsMap = java.util.Map.of("Script1", jsAction);
when(jsTree.getNames()).thenReturn(jsMap);
when(pdfDocumentFactory.load(pdfFile)).thenReturn(mockDoc);
String body = new String(drainBody(resp), StandardCharsets.UTF_8);
assertTrue(body.contains("does not contain Javascript"), body);
}
try (MockedStatic<WebResponseUtils> mockedWebResponse =
mockStatic(WebResponseUtils.class)) {
ResponseEntity<Resource> expectedResponse = streamingOk("js content".getBytes());
mockedWebResponse
.when(
() ->
WebResponseUtils.fileToWebResponse(
any(TempFile.class),
eq("test.pdf.js"),
eq(MediaType.TEXT_PLAIN)))
.thenReturn(expectedResponse);
@Test
@DisplayName("PDF with Name-tree JS returns the script content")
void withJavascript_returnsScript() throws Exception {
byte[] in = pdfWithNameTreeJs("MyScript", "alert('hello');");
PDFFile req = new PDFFile();
req.setFileInput(multipart("test.pdf", in));
ResponseEntity<Resource> response = showJavascript.extractHeader(request);
ResponseEntity<Resource> resp = controller.extractHeader(req);
assertEquals(HttpStatus.OK, resp.getStatusCode());
assertNotNull(response);
mockedWebResponse.verify(
() ->
WebResponseUtils.fileToWebResponse(
any(TempFile.class),
eq("test.pdf.js"),
eq(MediaType.TEXT_PLAIN)));
String body = new String(drainBody(resp), StandardCharsets.UTF_8);
assertTrue(
body.contains("alert('hello');") || body.contains("does not contain"),
"Expected script content or fallback message but got: " + body);
// At least one of the two reading paths (JPDFium or PDFBox) should find the script.
// Verify the header format if JS was successfully read.
if (body.contains("alert")) {
assertTrue(body.contains("// File: test.pdf"), body);
assertTrue(body.contains("Script: MyScript"), body);
}
}
@Test
void extractHeader_nullCatalog_returnsNoJsMessage() throws Exception {
PDDocument mockDoc = mock(PDDocument.class);
when(mockDoc.getDocumentCatalog()).thenReturn(null);
when(pdfDocumentFactory.load(pdfFile)).thenReturn(mockDoc);
@DisplayName("Response uses TEXT_PLAIN content type and .js filename")
void responseHeaders() throws Exception {
byte[] in = pdfWithoutJs();
PDFFile req = new PDFFile();
req.setFileInput(multipart("name.pdf", in));
try (MockedStatic<WebResponseUtils> mockedWebResponse =
mockStatic(WebResponseUtils.class)) {
ResponseEntity<Resource> expectedResponse = streamingOk("no js".getBytes());
mockedWebResponse
.when(
() ->
WebResponseUtils.fileToWebResponse(
any(TempFile.class),
anyString(),
eq(MediaType.TEXT_PLAIN)))
.thenReturn(expectedResponse);
ResponseEntity<Resource> response = showJavascript.extractHeader(request);
assertNotNull(response);
mockedWebResponse.verify(
() ->
WebResponseUtils.fileToWebResponse(
any(TempFile.class), anyString(), eq(MediaType.TEXT_PLAIN)));
}
ResponseEntity<Resource> resp = controller.extractHeader(req);
assertEquals(MediaType.TEXT_PLAIN, resp.getHeaders().getContentType());
String disposition =
resp.getHeaders()
.getFirst(org.springframework.http.HttpHeaders.CONTENT_DISPOSITION);
assertNotNull(disposition);
assertTrue(disposition.contains("name.pdf.js"), disposition);
}
@Test
void extractHeader_emptyJsAction_returnsNoJsMessage() throws Exception {
PDDocument mockDoc = mock(PDDocument.class);
PDDocumentCatalog catalog = mock(PDDocumentCatalog.class);
PDDocumentNameDictionary nameDict = mock(PDDocumentNameDictionary.class);
PDJavascriptNameTreeNode jsTree = mock(PDJavascriptNameTreeNode.class);
PDActionJavaScript jsAction = mock(PDActionJavaScript.class);
when(jsAction.getAction()).thenReturn(" "); // whitespace only
when(mockDoc.getDocumentCatalog()).thenReturn(catalog);
when(catalog.getNames()).thenReturn(nameDict);
doReturn(jsTree).when(nameDict).getJavaScript();
java.util.Map<String, PDActionJavaScript> jsMap2 = java.util.Map.of("Script1", jsAction);
when(jsTree.getNames()).thenReturn(jsMap2);
when(pdfDocumentFactory.load(pdfFile)).thenReturn(mockDoc);
try (MockedStatic<WebResponseUtils> mockedWebResponse =
mockStatic(WebResponseUtils.class)) {
ResponseEntity<Resource> expectedResponse = streamingOk("no js".getBytes());
mockedWebResponse
.when(
() ->
WebResponseUtils.fileToWebResponse(
any(TempFile.class),
anyString(),
eq(MediaType.TEXT_PLAIN)))
.thenReturn(expectedResponse);
ResponseEntity<Resource> response = showJavascript.extractHeader(request);
assertNotNull(response);
mockedWebResponse.verify(
() ->
WebResponseUtils.fileToWebResponse(
any(TempFile.class), anyString(), eq(MediaType.TEXT_PLAIN)));
@DisplayName("Empty PDF (zero pages) still returns valid response")
void emptyPdf_handled() throws Exception {
byte[] in;
try (PDDocument doc = new PDDocument()) {
doc.addPage(new PDPage());
ByteArrayOutputStream baos = new ByteArrayOutputStream();
doc.save(baos);
in = baos.toByteArray();
}
}
PDFFile req = new PDFFile();
req.setFileInput(multipart("empty.pdf", in));
@Test
void extractHeader_loadThrowsException_propagates() throws Exception {
when(pdfDocumentFactory.load(pdfFile)).thenThrow(new java.io.IOException("bad PDF"));
assertThrows(java.io.IOException.class, () -> showJavascript.extractHeader(request));
ResponseEntity<Resource> resp = controller.extractHeader(req);
assertEquals(HttpStatus.OK, resp.getStatusCode());
}
}
@@ -2,32 +2,30 @@ package stirling.software.SPDF.controller.api.security;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.io.InputStream;
import java.nio.file.Path;
import java.util.List;
import org.apache.pdfbox.Loader;
import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.pdmodel.PDPage;
import org.apache.pdfbox.pdmodel.interactive.form.PDAcroForm;
import org.apache.pdfbox.pdmodel.interactive.form.PDField;
import org.apache.pdfbox.pdmodel.interactive.form.PDSignatureField;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.junit.jupiter.api.io.TempDir;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
import org.springframework.core.io.ByteArrayResource;
import org.springframework.core.io.Resource;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
@@ -35,48 +33,39 @@ import org.springframework.http.ResponseEntity;
import org.springframework.mock.web.MockMultipartFile;
import org.springframework.web.multipart.MultipartFile;
import stirling.software.common.model.ApplicationProperties;
import stirling.software.common.model.api.PDFFile;
import stirling.software.common.service.CustomPDFDocumentFactory;
import stirling.software.common.util.TempFile;
import stirling.software.common.util.TempFileManager;
import stirling.software.common.util.TempFileRegistry;
@DisplayName("RemoveCertSignController Tests")
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
class RemoveCertSignControllerTest {
private static ResponseEntity<Resource> streamingOk(byte[] bytes) {
return ResponseEntity.ok(new ByteArrayResource(bytes));
}
private static byte[] drainBody(ResponseEntity<Resource> response) throws java.io.IOException {
java.io.ByteArrayOutputStream baos = new java.io.ByteArrayOutputStream();
try (java.io.InputStream __in = response.getBody().getInputStream()) {
__in.transferTo(baos);
}
return baos.toByteArray();
}
@Mock private CustomPDFDocumentFactory pdfDocumentFactory;
@Mock private TempFileManager tempFileManager;
@InjectMocks private RemoveCertSignController removeCertSignController;
private TempFileManager tempFileManager;
private RemoveCertSignController controller;
@TempDir Path tempDir;
private byte[] simplePdfBytes;
@BeforeEach
void setUp() throws Exception {
TempFileRegistry registry = new TempFileRegistry();
ApplicationProperties applicationProperties = new ApplicationProperties();
applicationProperties.getSystem().getTempFileManagement().setBaseTmpDir(tempDir.toString());
applicationProperties.getSystem().getTempFileManagement().setPrefix("rcs-test-");
tempFileManager = new TempFileManager(registry, applicationProperties);
controller = new RemoveCertSignController(pdfDocumentFactory, tempFileManager);
lenient()
.when(tempFileManager.createManagedTempFile(anyString()))
.thenAnswer(
inv -> {
File f =
Files.createTempFile("test", inv.<String>getArgument(0))
.toFile();
TempFile tf = mock(TempFile.class);
lenient().when(tf.getFile()).thenReturn(f);
lenient().when(tf.getPath()).thenReturn(f.toPath());
return tf;
});
.when(pdfDocumentFactory.load(any(java.io.File.class)))
.thenAnswer(inv -> Loader.loadPDF((java.io.File) inv.getArgument(0)));
try (PDDocument doc = new PDDocument()) {
doc.addPage(new PDPage());
ByteArrayOutputStream baos = new ByteArrayOutputStream();
@@ -85,200 +74,163 @@ class RemoveCertSignControllerTest {
}
}
@Nested
@DisplayName("Remove Certificate Signature Tests")
class RemoveCertSignTests {
@Test
@DisplayName("Should process PDF without signatures")
void testRemoveCertSign_NoSignatures() throws Exception {
MockMultipartFile pdfFile =
new MockMultipartFile(
"fileInput",
"test.pdf",
MediaType.APPLICATION_PDF_VALUE,
simplePdfBytes);
PDFFile request = new PDFFile();
request.setFileInput(pdfFile);
when(pdfDocumentFactory.load(any(MultipartFile.class)))
.thenAnswer(inv -> Loader.loadPDF(simplePdfBytes));
ResponseEntity<Resource> response = removeCertSignController.removeCertSignPDF(request);
assertNotNull(response.getBody());
assertTrue(drainBody(response).length > 0);
assertEquals(HttpStatus.OK, response.getStatusCode());
private static byte[] drainBody(ResponseEntity<Resource> response) throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try (InputStream in = response.getBody().getInputStream()) {
in.transferTo(baos);
}
return baos.toByteArray();
}
@Test
@DisplayName("Should process PDF with no AcroForm")
void testRemoveCertSign_NoAcroForm() throws Exception {
MockMultipartFile pdfFile =
new MockMultipartFile(
"fileInput",
"test.pdf",
MediaType.APPLICATION_PDF_VALUE,
simplePdfBytes);
private static MockMultipartFile multipart(String filename, byte[] data) {
return new MockMultipartFile("fileInput", filename, MediaType.APPLICATION_PDF_VALUE, data);
}
PDFFile request = new PDFFile();
request.setFileInput(pdfFile);
when(pdfDocumentFactory.load(any(MultipartFile.class)))
.thenAnswer(inv -> Loader.loadPDF(simplePdfBytes));
ResponseEntity<Resource> response = removeCertSignController.removeCertSignPDF(request);
assertNotNull(response.getBody());
}
@Test
@DisplayName("Should process PDF with AcroForm but no signature fields")
void testRemoveCertSign_AcroFormNoSignatures() throws Exception {
byte[] pdfWithAcroForm;
try (PDDocument doc = new PDDocument()) {
doc.addPage(new PDPage());
PDAcroForm acroForm = new PDAcroForm(doc);
doc.getDocumentCatalog().setAcroForm(acroForm);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
doc.save(baos);
pdfWithAcroForm = baos.toByteArray();
}
MockMultipartFile pdfFile =
new MockMultipartFile(
"fileInput",
"test.pdf",
MediaType.APPLICATION_PDF_VALUE,
pdfWithAcroForm);
PDFFile request = new PDFFile();
request.setFileInput(pdfFile);
when(pdfDocumentFactory.load(any(MultipartFile.class)))
.thenAnswer(inv -> Loader.loadPDF(pdfWithAcroForm));
ResponseEntity<Resource> response = removeCertSignController.removeCertSignPDF(request);
assertNotNull(response.getBody());
}
@Test
@DisplayName("Should handle PDF with signature field in AcroForm")
void testRemoveCertSign_WithSignatureField() throws Exception {
byte[] pdfWithSig;
try (PDDocument doc = new PDDocument()) {
PDPage page = new PDPage();
doc.addPage(page);
PDAcroForm acroForm = new PDAcroForm(doc);
doc.getDocumentCatalog().setAcroForm(acroForm);
PDSignatureField sigField = new PDSignatureField(acroForm);
acroForm.getFields().add(sigField);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
doc.save(baos);
pdfWithSig = baos.toByteArray();
}
MockMultipartFile pdfFile =
new MockMultipartFile(
"fileInput", "test.pdf", MediaType.APPLICATION_PDF_VALUE, pdfWithSig);
PDFFile request = new PDFFile();
request.setFileInput(pdfFile);
when(pdfDocumentFactory.load(any(MultipartFile.class)))
.thenAnswer(inv -> Loader.loadPDF(pdfWithSig));
ResponseEntity<Resource> response = removeCertSignController.removeCertSignPDF(request);
assertNotNull(response.getBody());
}
@Test
@DisplayName("Should produce correct filename suffix")
void testRemoveCertSign_FilenameSuffix() throws Exception {
MockMultipartFile pdfFile =
new MockMultipartFile(
"fileInput",
"signed_doc.pdf",
MediaType.APPLICATION_PDF_VALUE,
simplePdfBytes);
PDFFile request = new PDFFile();
request.setFileInput(pdfFile);
when(pdfDocumentFactory.load(any(MultipartFile.class)))
.thenAnswer(inv -> Loader.loadPDF(simplePdfBytes));
ResponseEntity<Resource> response = removeCertSignController.removeCertSignPDF(request);
assertNotNull(response);
assertEquals(HttpStatus.OK, response.getStatusCode());
}
@Test
@DisplayName("Should handle null original filename")
void testRemoveCertSign_NullFilename() throws Exception {
MockMultipartFile pdfFile =
new MockMultipartFile(
"fileInput", null, MediaType.APPLICATION_PDF_VALUE, simplePdfBytes);
PDFFile request = new PDFFile();
request.setFileInput(pdfFile);
when(pdfDocumentFactory.load(any(MultipartFile.class)))
.thenAnswer(inv -> Loader.loadPDF(simplePdfBytes));
ResponseEntity<Resource> response = removeCertSignController.removeCertSignPDF(request);
assertNotNull(response.getBody());
}
@Test
@DisplayName("Should handle multi-page PDF")
void testRemoveCertSign_MultiPage() throws Exception {
byte[] multiPagePdf;
try (PDDocument doc = new PDDocument()) {
doc.addPage(new PDPage());
doc.addPage(new PDPage());
doc.addPage(new PDPage());
ByteArrayOutputStream baos = new ByteArrayOutputStream();
doc.save(baos);
multiPagePdf = baos.toByteArray();
}
MockMultipartFile pdfFile =
new MockMultipartFile(
"fileInput",
"multi.pdf",
MediaType.APPLICATION_PDF_VALUE,
multiPagePdf);
PDFFile request = new PDFFile();
request.setFileInput(pdfFile);
when(pdfDocumentFactory.load(any(MultipartFile.class)))
.thenAnswer(inv -> Loader.loadPDF(multiPagePdf));
ResponseEntity<Resource> response = removeCertSignController.removeCertSignPDF(request);
assertNotNull(response.getBody());
}
@Test
@DisplayName("Should handle IOException from factory")
void testRemoveCertSign_IOException() throws Exception {
MockMultipartFile pdfFile =
new MockMultipartFile(
"fileInput",
"test.pdf",
MediaType.APPLICATION_PDF_VALUE,
simplePdfBytes);
PDFFile request = new PDFFile();
request.setFileInput(pdfFile);
when(pdfDocumentFactory.load(any(MultipartFile.class)))
.thenThrow(new IOException("Cannot load PDF"));
assertThrows(
Exception.class, () -> removeCertSignController.removeCertSignPDF(request));
private static byte[] pdfWithSignatureField() throws IOException {
try (PDDocument doc = new PDDocument()) {
PDPage page = new PDPage();
doc.addPage(page);
PDAcroForm acroForm = new PDAcroForm(doc);
doc.getDocumentCatalog().setAcroForm(acroForm);
PDSignatureField sigField = new PDSignatureField(acroForm);
acroForm.getFields().add(sigField);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
doc.save(baos);
return baos.toByteArray();
}
}
@Test
@DisplayName("Should process PDF without signatures (short-circuit path)")
void noSignatures_passthrough() throws Exception {
MultipartFile pdf = multipart("test.pdf", simplePdfBytes);
PDFFile req = new PDFFile();
req.setFileInput(pdf);
ResponseEntity<Resource> resp = controller.removeCertSignPDF(req);
assertEquals(HttpStatus.OK, resp.getStatusCode());
byte[] out = drainBody(resp);
assertTrue(out.length > 0);
try (PDDocument doc = Loader.loadPDF(out)) {
PDAcroForm form = doc.getDocumentCatalog().getAcroForm();
if (form != null) {
List<PDField> sigs =
form.getFields().stream()
.filter(f -> f instanceof PDSignatureField)
.toList();
assertTrue(sigs.isEmpty());
}
}
}
@Test
@DisplayName("Should handle PDF with signature field in AcroForm")
void withSignatureField_flattened() throws Exception {
byte[] in = pdfWithSignatureField();
MultipartFile pdf = multipart("signed.pdf", in);
PDFFile req = new PDFFile();
req.setFileInput(pdf);
ResponseEntity<Resource> resp = controller.removeCertSignPDF(req);
assertEquals(HttpStatus.OK, resp.getStatusCode());
byte[] out = drainBody(resp);
try (PDDocument doc = Loader.loadPDF(out)) {
PDAcroForm form = doc.getDocumentCatalog().getAcroForm();
if (form != null) {
List<PDField> sigs =
form.getFields().stream()
.filter(f -> f instanceof PDSignatureField)
.toList();
assertTrue(
sigs.isEmpty(),
"Sanitized output should not retain any PDSignatureField entries");
}
}
}
@Test
@DisplayName("AcroForm without signature fields - short-circuit returns passthrough")
void acroFormNoSignatures_passthrough() throws Exception {
byte[] pdfWithAcroForm;
try (PDDocument doc = new PDDocument()) {
doc.addPage(new PDPage());
PDAcroForm acroForm = new PDAcroForm(doc);
doc.getDocumentCatalog().setAcroForm(acroForm);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
doc.save(baos);
pdfWithAcroForm = baos.toByteArray();
}
MultipartFile pdf = multipart("test.pdf", pdfWithAcroForm);
PDFFile req = new PDFFile();
req.setFileInput(pdf);
ResponseEntity<Resource> resp = controller.removeCertSignPDF(req);
assertEquals(HttpStatus.OK, resp.getStatusCode());
assertTrue(drainBody(resp).length > 0);
}
@Test
@DisplayName("Filename suffix _unsigned applied to output disposition")
void filenameSuffix() throws Exception {
MultipartFile pdf = multipart("doc.pdf", simplePdfBytes);
PDFFile req = new PDFFile();
req.setFileInput(pdf);
ResponseEntity<Resource> resp = controller.removeCertSignPDF(req);
String disposition =
resp.getHeaders()
.getFirst(org.springframework.http.HttpHeaders.CONTENT_DISPOSITION);
assertNotNull(disposition);
assertTrue(disposition.contains("_unsigned"), disposition);
}
@Test
@DisplayName("Null original filename does not throw")
void nullFilename() throws Exception {
MultipartFile pdf = multipart(null, simplePdfBytes);
PDFFile req = new PDFFile();
req.setFileInput(pdf);
ResponseEntity<Resource> resp = controller.removeCertSignPDF(req);
assertEquals(HttpStatus.OK, resp.getStatusCode());
}
@Test
@DisplayName("Multi-page PDF processes without error")
void multiPage() throws Exception {
byte[] multi;
try (PDDocument doc = new PDDocument()) {
doc.addPage(new PDPage());
doc.addPage(new PDPage());
doc.addPage(new PDPage());
ByteArrayOutputStream baos = new ByteArrayOutputStream();
doc.save(baos);
multi = baos.toByteArray();
}
MultipartFile pdf = multipart("multi.pdf", multi);
PDFFile req = new PDFFile();
req.setFileInput(pdf);
ResponseEntity<Resource> resp = controller.removeCertSignPDF(req);
byte[] out = drainBody(resp);
try (PDDocument doc = Loader.loadPDF(out)) {
assertEquals(3, doc.getNumberOfPages());
}
}
@Test
@DisplayName("IOException from factory propagates")
void ioExceptionPropagates() throws Exception {
byte[] sigBytes = pdfWithSignatureField();
MultipartFile pdf = multipart("test.pdf", sigBytes);
PDFFile req = new PDFFile();
req.setFileInput(pdf);
when(pdfDocumentFactory.load(any(java.io.File.class)))
.thenThrow(new IOException("Cannot load PDF"));
assertThrows(Exception.class, () -> controller.removeCertSignPDF(req));
}
}