Merge branch 'master' into subtree

[nikiroo-utils.git] / test / ConversionTest.java

package be.nikiroo.fanfix.test;

import java.io.File;
import java.io.FilenameFilter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import be.nikiroo.fanfix.Instance;
import be.nikiroo.fanfix.Main;
import be.nikiroo.fanfix.output.BasicOutput;
import be.nikiroo.fanfix.output.BasicOutput.OutputType;
import be.nikiroo.utils.IOUtils;
import be.nikiroo.utils.Progress;
import be.nikiroo.utils.TraceHandler;
import be.nikiroo.utils.test.TestCase;
import be.nikiroo.utils.test.TestLauncher;

class ConversionTest extends TestLauncher {
	private class MainWithConvert extends Main {
		@Override
		public int convert(String urlString, OutputType type, String target,
				boolean infoCover, Progress pg) {
			return super.convert(urlString, type, target, infoCover, pg);
		}
	}
	
	private String testUri;
	private String expectedDir;
	private String resultDir;
	private List<BasicOutput.OutputType> realTypes;
	private Map<String, List<String>> skipCompare;
	private Map<String, List<String>> skipCompareCross;

	public ConversionTest(String testName, final String testUri,
			final String expectedDir, final String resultDir, String[] args) {
		super("Conversion - " + testName, args);

		this.testUri = testUri;
		this.expectedDir = expectedDir;
		this.resultDir = resultDir;

		// Special mode SYSOUT is not a file type (System.out)
		realTypes = new ArrayList<BasicOutput.OutputType>();
		for (BasicOutput.OutputType type : BasicOutput.OutputType.values()) {
			if (!BasicOutput.OutputType.SYSOUT.equals(type)) {
				realTypes.add(type);
			}
		}

		if (!testUri.startsWith("http://") && !testUri.startsWith("https://")) {
			addTest(new TestCase("Read the test file") {
				@Override
				public void test() throws Exception {
					assertEquals("The test file \"" + testUri
							+ "\" cannot be found", true,
							new File(testUri).exists());
				}
			});
		}

		addTest(new TestCase("Assure directories exist") {
			@Override
			public void test() throws Exception {
				new File(expectedDir).mkdirs();
				new File(resultDir).mkdirs();
				assertEquals("The Expected directory \"" + expectedDir
						+ "\" cannot be created", true,
						new File(expectedDir).exists());
				assertEquals("The Result directory \"" + resultDir
						+ "\" cannot be created", true,
						new File(resultDir).exists());
			}
		});

		for (BasicOutput.OutputType type : realTypes) {
			addTest(getTestFor(type));
		}
	}

	@Override
	protected void start() throws Exception {
		skipCompare = new HashMap<String, List<String>>();
		skipCompareCross = new HashMap<String, List<String>>();

		skipCompare.put("epb.ncx", Arrays.asList(
				"		<meta name=\"dtb:uid\" content=",
				"		<meta name=\"epub-creator\" content=\""));
		skipCompare.put("epb.opf", Arrays.asList("      <dc:subject>",
				"      <dc:identifier id=\"BookId\" opf:scheme=\"URI\">"));
		skipCompare.put(".info", Arrays.asList("CREATION_DATE=",
				"URL=\"file:/", "UUID=EPUBCREATOR=\"", ""));
		skipCompare.put("URL", Arrays.asList("file:/"));

		for (String key : skipCompare.keySet()) {
			skipCompareCross.put(key, skipCompare.get(key));
		}

		skipCompareCross.put(".info", Arrays.asList(""));
		skipCompareCross.put("epb.opf", Arrays.asList("      <dc:"));
		skipCompareCross.put("title.xhtml",
				Arrays.asList("			<div class=\"type\">"));
		skipCompareCross.put("index.html",
				Arrays.asList("			<div class=\"type\">"));
		skipCompareCross.put("URL", Arrays.asList(""));
	}

	@Override
	protected void stop() throws Exception {
	}

	private TestCase getTestFor(final BasicOutput.OutputType type) {
		return new TestCase(type + " output mode") {
			@Override
			public void test() throws Exception {
				File target = generate(this, testUri, new File(resultDir), type);
				target = new File(target.getAbsolutePath()
						+ type.getDefaultExtension(false));

				// Check conversion:
				compareFiles(this, new File(expectedDir), new File(resultDir),
						type, "Generate " + type);

				// LATEX not supported as input
				if (BasicOutput.OutputType.LATEX.equals(type)) {
					return;
				}

				// Cross-checks:
				for (BasicOutput.OutputType crossType : realTypes) {
					File crossDir = Test.tempFiles
							.createTempDir("cross-result");

					generate(this, target.getAbsolutePath(), crossDir,
							crossType);
					compareFiles(this, new File(resultDir), crossDir,
							crossType, "Cross compare " + crossType
									+ " generated from " + type);
				}
			}
		};
	}

	private File generate(TestCase testCase, String testUri, File resultDir,
			BasicOutput.OutputType type) throws Exception {
		final List<String> errors = new ArrayList<String>();

		TraceHandler previousTraceHandler = Instance.getInstance().getTraceHandler();
		Instance.getInstance().setTraceHandler(new TraceHandler(true, true, 0) {
			@Override
			public void error(String message) {
				errors.add(message);
			}

			@Override
			public void error(Exception e) {
				error(" ");
				for (Throwable t = e; t != null; t = t.getCause()) {
					error(((t == e) ? "(" : "..caused by: (")
							+ t.getClass().getSimpleName() + ") "
							+ t.getMessage());
					for (StackTraceElement s : t.getStackTrace()) {
						error("\t" + s.toString());
					}
				}
			}
		});

		try {
			File target = new File(resultDir, type.toString());
			int code = new MainWithConvert().convert(testUri, type,
					target.getAbsolutePath(), false, null);

			String error = "";
			for (String err : errors) {
				if (!error.isEmpty())
					error += "\n";
				error += err;
			}
			testCase.assertEquals("The conversion returned an error message: "
					+ error, 0, errors.size());
			if (code != 0) {
				testCase.fail("The conversion failed with return code: " + code);
			}

			return target;
		} finally {
			Instance.getInstance().setTraceHandler(previousTraceHandler);
		}
	}

	private void compareFiles(TestCase testCase, File expectedDir,
			File resultDir, final BasicOutput.OutputType limitTiFiles,
			final String errMess) throws Exception {

		Map<String, List<String>> skipCompare = errMess.startsWith("Cross") ? this.skipCompareCross
				: this.skipCompare;

		FilenameFilter filter = null;
		if (limitTiFiles != null) {
			filter = new FilenameFilter() {
				@Override
				public boolean accept(File dir, String name) {
					return name.toLowerCase().startsWith(
							limitTiFiles.toString().toLowerCase());
				}
			};
		}

		List<String> resultFiles;
		List<String> expectedFiles;
		{
			String[] resultArr = resultDir.list(filter);
			Arrays.sort(resultArr);
			resultFiles = Arrays.asList(resultArr);
			String[] expectedArr = expectedDir.list(filter);
			Arrays.sort(expectedArr);
			expectedFiles = Arrays.asList(expectedArr);
		}

		testCase.assertEquals(errMess, expectedFiles, resultFiles);

		for (int i = 0; i < resultFiles.size(); i++) {
			File expected = new File(expectedDir, expectedFiles.get(i));
			File result = new File(resultDir, resultFiles.get(i));

			testCase.assertEquals(errMess + ": type mismatch: expected a "
					+ (expected.isDirectory() ? "directory" : "file")
					+ ", received a "
					+ (result.isDirectory() ? "directory" : "file"),
					expected.isDirectory(), result.isDirectory());

			if (expected.isDirectory()) {
				compareFiles(testCase, expected, result, null, errMess);
				continue;
			}

			if (expected.getName().endsWith(".cbz")
					|| expected.getName().endsWith(".epub")) {
				File tmpExpected = Test.tempFiles.createTempDir(expected
						.getName() + "[zip-content]");
				File tmpResult = Test.tempFiles.createTempDir(result.getName()
						+ "[zip-content]");
				IOUtils.unzip(expected, tmpExpected);
				IOUtils.unzip(result, tmpResult);
				compareFiles(testCase, tmpExpected, tmpResult, null, errMess);
			} else {
				List<String> expectedLines = Arrays.asList(IOUtils
						.readSmallFile(expected).split("\n"));
				List<String> resultLines = Arrays.asList(IOUtils.readSmallFile(
						result).split("\n"));

				String name = expected.getAbsolutePath();
				if (name.startsWith(expectedDir.getAbsolutePath())) {
					name = expectedDir.getName()
							+ name.substring(expectedDir.getAbsolutePath()
									.length());
				}

				testCase.assertEquals(errMess + ": " + name
						+ ": the number of lines is not the same",
						expectedLines.size(), resultLines.size());

				for (int j = 0; j < expectedLines.size(); j++) {
					String expectedLine = expectedLines.get(j);
					String resultLine = resultLines.get(j);

					boolean skip = false;
					for (Entry<String, List<String>> skipThose : skipCompare
							.entrySet()) {
						for (String skipStart : skipThose.getValue()) {
							if (name.endsWith(skipThose.getKey())
									&& expectedLine.startsWith(skipStart)
									&& resultLine.startsWith(skipStart)) {
								skip = true;
							}
						}
					}

					if (skip) {
						continue;
					}

					testCase.assertEquals(errMess + ": line " + (j + 1)
							+ " is not the same in file " + name, expectedLine,
							resultLine);
				}
			}
		}
	}
}