org.sejda.tests.tasks.TaskTestContext Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of sejda-tests Show documentation
Show all versions of sejda-tests Show documentation
Package containing test utilities for Sejda.
/*
* Created on 12 gen 2016
* Copyright 2015 by Andrea Vacondio ([email protected]).
* This file is part of Sejda.
*
* Sejda is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Sejda is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with Sejda. If not, see outputFiles = Arrays.stream(fileOutput.listFiles()).map(File::getName).collect(Collectors.toSet());
Arrays.stream(filenames).forEach(f -> assertTrue(outputFiles.contains(f),
f + " missing but expected. Files were: " + StringUtils.join(outputFiles)));
return this;
}
/**
* Applies the given consumer to every generated output
*
* @param consumer
* @return
* @throws IOException
*/
public TaskTestContext forEachPdfOutput(Consumer consumer) throws IOException {
if (nonNull(outputDocument)) {
requirePDDocument();
consumer.accept(outputDocument);
} else if (nonNull(fileOutput) && fileOutput.isDirectory()) {
requireMultipleOutputs();
for (File current : fileOutput.listFiles()) {
try (PDDocument doc = PDFParser.parse(SeekableSources.seekableSourceFrom(current))) {
consumer.accept(doc);
}
}
} else {
fail("No output to apply to");
}
return this;
}
/**
* Applies the given consumer to generated single output PDF document
*
* @param consumer
* @return
* @throws IOException
*/
public TaskTestContext forPdfOutput(Consumer consumer) {
requirePDDocument();
consumer.accept(outputDocument);
return this;
}
/**
* Applies the given consumer to generated output PDF document with the given name
*
* @param consumer
* @return
* @throws IOException
*/
public TaskTestContext forPdfOutput(String filename, Consumer consumer) throws IOException {
requireMultipleOutputs();
assertTrue(isNotEmpty(filename) && filename.toLowerCase().endsWith(SejdaFileExtensions.PDF_EXTENSION),
"Not a PDF output");
try (PDDocument doc = PDFParser.parse(SeekableSources.seekableSourceFrom(new File(fileOutput, filename)))) {
consumer.accept(doc);
}
return this;
}
/**
* Applies the given consumer to every generated output
*
* @param consumer
* @return
* @throws IOException
*/
public TaskTestContext forEachRawOutput(Consumer consumer) throws IOException {
requireMultipleOutputs();
Files.list(fileOutput.toPath()).forEach(consumer);
return this;
}
/**
* Applies the given consumer to a single generated output
*
* @param consumer
* @return
* @throws IOException
*/
public TaskTestContext forRawOutput(Consumer consumer) {
assertNotNull(fileOutput);
consumer.accept(fileOutput.toPath());
return this;
}
public TaskTestContext forRawOutput(String filename, Consumer consumer) {
requireMultipleOutputs();
File file = new File(fileOutput, filename);
assertTrue(file.exists());
consumer.accept(file.toPath());
return this;
}
private void requireMultipleOutputs() {
assertNotNull(fileOutput);
assertTrue(fileOutput.isDirectory(), "Expected an output directory");
assertTrue(fileOutput.listFiles().length > 0, "No output has been created");
}
private void requirePDDocument() {
Assertions.assertNotNull(outputDocument,
"No output document, make sure to call TaskTestContext::assertTaskCompleted before any other assert method");
}
/**
* Asserts that the task has completed and generated some output. If a single output task, then the output is paresed and a {@link PDDocument} is returned
*
* @return
* @throws IOException
*/
public PDDocument assertTaskCompleted() throws IOException {
return this.assertTaskCompleted(null);
}
/**
* Asserts that the task has completed and generated some output. If the task generated a single output, then the output is parsed and a {@link PDDocument} is returned
*
* @param password
* @return
* @throws IOException
*/
public PDDocument assertTaskCompleted(String password) throws IOException {
// First and foremost, check if the task failed.
this.assertTaskDidNotFail();
// look at outputs
// TODO: ignore leftover tmp buffers while doing this
if (nonNull(fileOutput)) {
if (fileOutput.isDirectory()) {
File[] files = fileOutput.listFiles();
assertTrue(files.length > 0, "No output has been created");
if (files.length == 1) {
initOutputFromSource(files[0], password);
}
} else {
initOutputFromSource(fileOutput, password);
}
} else if (nonNull(streamOutput)) {
org.sejda.commons.util.IOUtils.close(streamOutput);
initOutputFromSource(SeekableSources.inMemorySeekableSourceFrom(streamOutput.toByteArray()), password);
}
return outputDocument;
}
Throwable taskFailureCause = null;
String failedSource;
List taskWarnings = new ArrayList<>();
public List getTaskWarnings() {
return Collections.unmodifiableList(taskWarnings);
}
private TestListenerFactory.TestListenerStart startListener = TestListenerFactory.newStartListener();
private EventListener warningsListener = new EventListener<>() {
@Override
public void onEvent(TaskExecutionWarningEvent event) {
taskWarnings.add(event.getWarning());
}
};
private EventListener failureListener = new EventListener<>() {
@Override
public void onEvent(TaskExecutionFailedEvent event) {
taskFailureCause = event.getFailingCause();
failedSource = event.getNotifiableTaskMetadata().getCurrentSource();
}
};
public void listenForTaskFailure() {
taskFailureCause = null;
GlobalNotificationContext.getContext().removeListener(failureListener);
GlobalNotificationContext.getContext().addListener(failureListener);
}
public void listenForTaskStart() {
GlobalNotificationContext.getContext().removeListener(startListener);
GlobalNotificationContext.getContext().addListener(startListener);
}
public TaskTestContext assertTaskFailed(String message) {
assertNotNull(taskFailureCause);
assertThat(taskFailureCause.getMessage(), startsWith(message));
return this;
}
public TaskTestContext assertTaskFailed(Class cause) {
assertNotNull(taskFailureCause);
assertThat(taskFailureCause, instanceOf(cause));
return this;
}
public TaskTestContext assertTaskFailed() {
assertNotNull(taskFailureCause);
return this;
}
public TaskTestContext assertFailedSource(String source) {
assertEquals(source, failedSource);
return this;
}
public TaskTestContext assertTaskStarted() {
Assertions.assertTrue(startListener.isStarted());
return this;
}
public TaskTestContext assertTaskDidNotFail() {
assertNull(taskFailureCause, "Task failed");
return this;
}
@Deprecated
public void expectTaskWillProduceWarnings() {
listenForTaskWarnings();
}
public void listenForTaskWarnings() {
taskWarnings = new ArrayList<>();
GlobalNotificationContext.getContext().removeListener(warningsListener);
GlobalNotificationContext.getContext().addListener(warningsListener);
}
public TaskTestContext assertTaskWarning(String message) {
assertThat(taskWarnings, hasItem(containsString(message)));
return this;
}
public TaskTestContext assertTaskWarnings(List messages) {
assertEquals(taskWarnings, messages);
return this;
}
public TaskTestContext assertNoTaskWarnings() {
assertEquals(taskWarnings.size(), 0, "Expected no warnings but got: " + StringUtils.join(taskWarnings, ","));
return this;
}
private void initOutputFromSource(File source, String password) throws IOException {
if (source.getName().toLowerCase().endsWith(SejdaFileExtensions.PDF_EXTENSION)) {
this.outputDocument = PDFParser.parse(SeekableSources.seekableSourceFrom(source), password);
assertNotNull(outputDocument);
}
}
private void initOutputFromSource(SeekableSource source, String password) throws IOException {
this.outputDocument = PDFParser.parse(source, password);
assertNotNull(outputDocument);
}
@Override
public void close() throws IOException {
IOUtils.closeQuietly(streamOutput);
this.streamOutput = null;
IOUtils.closeQuietly(outputDocument);
this.outputDocument = null;
if (nonNull(fileOutput)) {
if (fileOutput.isDirectory()) {
Files.walkFileTree(fileOutput.toPath(), new SimpleFileVisitor<>() {
@Override
public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
Files.delete(file);
return FileVisitResult.CONTINUE;
}
@Override
public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
Files.delete(dir);
return FileVisitResult.CONTINUE;
}
});
}
Files.deleteIfExists(fileOutput.toPath());
}
this.fileOutput = null;
}
public File getFileOutput() {
return fileOutput;
}
public void assertSimilar(String filename, String resourcePath) throws IOException {
//debug(FilenameUtils.getName(resourcePath));
this.forPdfOutput(filename, actual -> new PixelCompareUtils().assertSimilar(actual, resourcePath));
}
public void assertSimilar(String resourcePath) {
//debug(FilenameUtils.getName(resourcePath));
this.forPdfOutput(actual -> new PixelCompareUtils().assertSimilar(actual, resourcePath));
}
public void assertSimilar(String resourcePath, double similarityThreshold) {
//debug(FilenameUtils.getName(resourcePath));
this.forPdfOutput(actual -> new PixelCompareUtils(similarityThreshold).assertSimilar(actual, resourcePath));
}
public void assertSimilar(String filename, String resourcePath, double similarityThreshold) throws IOException {
//debug(FilenameUtils.getName(resourcePath));
this.forPdfOutput(filename, actual -> new PixelCompareUtils(similarityThreshold).assertSimilar(actual, resourcePath));
}
public void debug(String filename) {
File dest = new File(SystemUtils.getJavaIoTmpDir(), filename);
debugTo(dest.getAbsolutePath());
System.out.println(dest);
}
public void debugTo(String destPath) {
try {
this.forEachRawOutput(path -> {
try {
FileUtils.copyFile(path.toFile(), new File(destPath));
} catch (IOException e) {
throw new RuntimeException(e);
}
});
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}