diff options
Diffstat (limited to 'pdf-as-tests/src/test/java/at/gv/egiz/param_tests/PDFASignatureTest.java')
-rw-r--r-- | pdf-as-tests/src/test/java/at/gv/egiz/param_tests/PDFASignatureTest.java | 166 |
1 files changed, 166 insertions, 0 deletions
diff --git a/pdf-as-tests/src/test/java/at/gv/egiz/param_tests/PDFASignatureTest.java b/pdf-as-tests/src/test/java/at/gv/egiz/param_tests/PDFASignatureTest.java new file mode 100644 index 00000000..e5c8e1be --- /dev/null +++ b/pdf-as-tests/src/test/java/at/gv/egiz/param_tests/PDFASignatureTest.java @@ -0,0 +1,166 @@ +package at.gv.egiz.param_tests; + +import static org.junit.Assert.assertTrue; + +import java.io.Closeable; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.IOException; +import java.security.cert.CertificateException; +import java.util.Collection; + +import org.apache.commons.io.IOUtils; +import org.apache.commons.lang3.tuple.ImmutablePair; +import org.apache.commons.lang3.tuple.Pair; +import org.apache.pdfbox.preflight.PreflightDocument; +import org.apache.pdfbox.preflight.ValidationResult; +import org.apache.pdfbox.preflight.exception.SyntaxValidationException; +import org.apache.pdfbox.preflight.parser.PreflightParser; +import org.junit.Assume; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; +import org.junit.runners.Parameterized.Parameters; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import at.gv.egiz.param_tests.provider.BaseSignatureTestData; +import at.gv.egiz.param_tests.provider.PDFAProvider; +import at.gv.egiz.param_tests.serialization.SerializiationManager; +import at.gv.egiz.param_tests.serialization.html.PDFAHTMLSerizalier; +import at.gv.egiz.param_tests.testinfo.PDFATestInfo; +import at.gv.egiz.pdfas.common.exceptions.PdfAsException; + +/** + * Parameterized unit-test for checking if a PDF-file is PDFA conform after + * signing. The test result is inconclusive if the file is already not conform + * before signing. + * + * @author mtappler + * + */ +@RunWith(Parameterized.class) +public class PDFASignatureTest extends SignatureTest { + + /** + * the logger for this class + */ + private static final Logger logger = LoggerFactory + .getLogger(PDFASignatureTest.class); + + /** + * Sets up this class, which includes registering a serializer for it, + * respectively the test type. + */ + @BeforeClass + public static void setUpClass() { + SerializiationManager.getInstance().registerSerializer( + new PDFAHTMLSerizalier(), PDFATestInfo.class); + } + + /** + * Constructor which sets the parameter for this parameterized unit test. + * + * @param testDirectory + * name of the directory of this test + * @param testName + * the name of this test + * @param testData + * basic test data, like connector, or signature profile + */ + public PDFASignatureTest(String testDirectory, String testName, + BaseSignatureTestData testData) { + this.baseTestData = testData; + } + + /** + * Static data-function, which is needed for JUnit's parameterized tests. It + * returns one collection item per test, which contains one array element + * per constructor parameter. + * + * @return the parameterized test data + */ + //@Parameters(name = "{index}-pdfa signature test:<{0}> - {1}") + @Parameters(name = "{index}-{1}") + public static Collection<Object[]> data() { + return new PDFAProvider().gatherData(); + } + + /** + * The actual unit test which is executed, it checks if the input is + * PDFA-conform, signs the PDF file and checks if the signing result is + * PDFA-conform. If the input file is not PDF-conform the test is skipped as + * being inconclusive. + * + * @throws CertificateException + * @throws FileNotFoundException + * @throws IOException + * @throws PdfAsException + */ + @Test + public void pdfaTest() throws CertificateException, FileNotFoundException, + IOException, PdfAsException { + PDFATestInfo testInfo = SerializiationManager.getInstance() + .createTestInfo(PDFATestInfo.class, baseTestData); + assertTrue("No input file given", baseTestData.getPdfFile() != null); + File inputFile = new File(baseTestData.getPdfFile()); + assertTrue("Given input file must exists", inputFile.exists()); + Pair<ValidationResult, Throwable> resultBeforeSign = checkPDFAConformance(inputFile); + testInfo.setResultBeforeSign(resultBeforeSign); + Assume.assumeTrue("Input should conform to PDF-A standard", + resultBeforeSign.getLeft() != null + && resultBeforeSign.getLeft().isValid()); + File outputPdfFile = signPDFFile(); + logger.debug("Signed document " + baseTestData.getOutputFile()); + + Pair<ValidationResult, Throwable> resultAfterSign = checkPDFAConformance(outputPdfFile); + testInfo.setResultAfterSign(resultAfterSign); + assertTrue("Output file must be PDF-A conform", + resultAfterSign.getLeft() != null + && resultAfterSign.getLeft().isValid()); + } + + /** + * Helper method for checking PDFA-conformance. + * + * @param fd + * the File object corresponding to the file, which should be + * checked. + * @return a pair consisting of the validation result and an exception, + * which might have been thrown during the validation (both possibly + * null) + */ + private Pair<ValidationResult, Throwable> checkPDFAConformance(File fd) { + PreflightDocument document = null; + ValidationResult result = null; + try { + PreflightParser parser = new PreflightParser(fd); + parser.parse(); + document = parser.getPreflightDocument(); + document.validate(); + document.close(); + result = document.getResult(); + return new ImmutablePair<ValidationResult, Throwable>(result, null); + } catch (SyntaxValidationException e) { + logger.debug("The file " + fd.getName() + + " is syntactically invalid.", e); + return new ImmutablePair<ValidationResult, Throwable>(result, e); + } catch (IOException e) { + logger.debug("An IOException (" + e.getMessage() + + ") occurred, while validating the PDF-A conformance of " + + fd.getName(), e); + return new ImmutablePair<ValidationResult, Throwable>(result, e); + } catch (RuntimeException e) { + logger.debug("An RuntimeException (" + e.getMessage() + + ") occurred, while validating the PDF-A conformance of " + + fd.getName(), e); + return new ImmutablePair<ValidationResult, Throwable>(result, e); + } finally { + if (document != null) { + IOUtils.closeQuietly((Closeable)document); + } + } + } + +} |