src/be/nikiroo/fanfix/test/ConversionTest.java

   1 package be.nikiroo.fanfix.test;
   2
   3 import java.io.File;
   4 import java.io.FileInputStream;
   5 import java.io.FilenameFilter;
   6 import java.io.IOException;
   7 import java.util.ArrayList;
   8 import java.util.Arrays;
   9 import java.util.List;
  10 import java.util.zip.ZipEntry;
  11 import java.util.zip.ZipInputStream;
  12
  13 import be.nikiroo.fanfix.Instance;
  14 import be.nikiroo.fanfix.Main;
  15 import be.nikiroo.fanfix.output.BasicOutput;
  16 import be.nikiroo.utils.IOUtils;
  17 import be.nikiroo.utils.TempFiles;
  18 import be.nikiroo.utils.TraceHandler;
  19 import be.nikiroo.utils.test.TestCase;
  20 import be.nikiroo.utils.test.TestLauncher;
  21
  22 class ConversionTest extends TestLauncher {
  23         private TempFiles tempFiles;
  24         private File testFile;
  25         private File expectedDir;
  26         private File resultDir;
  27
  28         public ConversionTest(String[] args) {
  29                 super("Conversion", args);
  30
  31                 addTest(new TestCase("Read the test file") {
  32                         @Override
  33                         public void test() throws Exception {
  34                                 assertEquals("The test file \"" + testFile
  35                                                 + "\" cannot be found", true, testFile.exists());
  36                         }
  37                 });
  38
  39                 addTest(new TestCase("Assure directories exist") {
  40                         @Override
  41                         public void test() throws Exception {
  42                                 expectedDir.mkdirs();
  43                                 resultDir.mkdirs();
  44                                 assertEquals("The Expected directory \"" + expectedDir
  45                                                 + "\" cannot be created", true, expectedDir.exists());
  46                                 assertEquals("The Result directory \"" + resultDir
  47                                                 + "\" cannot be created", true, resultDir.exists());
  48                         }
  49                 });
  50
  51                 for (BasicOutput.OutputType type : BasicOutput.OutputType.values()) {
  52                         // NOT for special mode SYSOUT
  53                         if (!BasicOutput.OutputType.SYSOUT.equals(type)) {
  54                                 addTest(getTestFor(type));
  55                         }
  56                 }
  57         }
  58
  59         @Override
  60         protected void start() throws Exception {
  61                 testFile = new File("test/test.story");
  62                 expectedDir = new File("test/expected/");
  63                 resultDir = new File("test/result/");
  64
  65                 tempFiles = new TempFiles("Fanfix-ConversionTest");
  66         }
  67
  68         @Override
  69         protected void stop() throws Exception {
  70                 tempFiles.close();
  71         }
  72
  73         private TestCase getTestFor(final BasicOutput.OutputType type) {
  74                 return new TestCase(type + " output mode") {
  75                         @Override
  76                         public void test() throws Exception {
  77                                 File target = generate(this, testFile, resultDir, type);
  78                                 target = new File(target.getAbsolutePath()
  79                                                 + type.getDefaultExtension(false));
  80
  81                                 // Check conversion:
  82                                 compareFiles(this, expectedDir, resultDir, type);
  83
  84                                 // Cross-checks:
  85                                 for (BasicOutput.OutputType type : BasicOutput.OutputType
  86                                                 .values()) {
  87                                         // NOT for special mode SYSOUT
  88                                         if (!BasicOutput.OutputType.SYSOUT.equals(type)) {
  89                                                 File crossDir = tempFiles.createTempDir("cross-result");
  90                                                 generate(this, target, crossDir, type);
  91                                                 compareFiles(this, crossDir, resultDir, type);
  92                                         }
  93                                 }
  94                         }
  95                 };
  96         }
  97
  98         private File generate(TestCase testCase, File testFile, File resultDir,
  99                         BasicOutput.OutputType type) throws Exception {
 100                 final List<String> errors = new ArrayList<String>();
 101
 102                 TraceHandler previousTraceHandler = Instance.getTraceHandler();
 103                 Instance.setTraceHandler(new TraceHandler(true, true, 0) {
 104                         @Override
 105                         public void error(String message) {
 106                                 errors.add(message);
 107                         }
 108
 109                         @Override
 110                         public void error(Exception e) {
 111                                 error(" ");
 112                                 for (Throwable t = e; t != null; t = t.getCause()) {
 113                                         error(((t == e) ? "(" : "..caused by: (")
 114                                                         + t.getClass().getSimpleName() + ") "
 115                                                         + t.getMessage());
 116                                         for (StackTraceElement s : t.getStackTrace()) {
 117                                                 error("\t" + s.toString());
 118                                         }
 119                                 }
 120                         }
 121                 });
 122
 123                 try {
 124                         File target = new File(resultDir, type.toString());
 125                         int code = Main.convert(testFile.getAbsolutePath(),
 126                                         type.toString(), target.getAbsolutePath(), false, null);
 127
 128                         String error = "";
 129                         for (String err : errors) {
 130                                 if (!error.isEmpty())
 131                                         error += "\n";
 132                                 error += err;
 133                         }
 134                         testCase.assertEquals("The conversion returned an error message: "
 135                                         + error, 0, errors.size());
 136                         if (code != 0) {
 137                                 testCase.fail("The conversion failed with return code: " + code);
 138                         }
 139
 140                         return target;
 141                 } finally {
 142                         Instance.setTraceHandler(previousTraceHandler);
 143                 }
 144         }
 145
 146         private void compareFiles(TestCase testCase, File expectedDir,
 147                         File resultDir, final BasicOutput.OutputType typeToCompare)
 148                         throws Exception {
 149
 150                 FilenameFilter filter = null;
 151                 if (typeToCompare != null) {
 152                         filter = new FilenameFilter() {
 153                                 @Override
 154                                 public boolean accept(File dir, String name) {
 155                                         return name.startsWith(typeToCompare.toString());
 156                                 }
 157                         };
 158                 }
 159
 160                 List<String> resultFiles = Arrays.asList(resultDir.list(filter));
 161                 resultFiles.sort(null);
 162                 List<String> expectedFiles = Arrays.asList(expectedDir.list(filter));
 163                 expectedFiles.sort(null);
 164
 165                 testCase.assertEquals("The resulting file names are not expected",
 166                                 expectedFiles, resultFiles);
 167
 168                 for (int i = 0; i < resultFiles.size(); i++) {
 169                         File expected = new File(expectedDir, expectedFiles.get(i));
 170                         File result = new File(resultDir, resultFiles.get(i));
 171
 172                         testCase.assertEquals(
 173                                         "Type mismatch: expected a "
 174                                                         + (expected.isDirectory() ? "directory" : "file")
 175                                                         + ", received a "
 176                                                         + (result.isDirectory() ? "directory" : "file"),
 177                                         expected.isDirectory(), result.isDirectory());
 178
 179                         if (expected.isDirectory()) {
 180                                 compareFiles(testCase, expected, result, null);
 181                                 continue;
 182                         }
 183
 184                         if (expected.getName().endsWith(".cbz")
 185                                         || expected.getName().endsWith(".epub")) {
 186                                 File tmpExpected = tempFiles.createTempDir(expected.getName()
 187                                                 + "[zip-content]");
 188                                 File tmpResult = tempFiles.createTempDir(result.getName()
 189                                                 + "[zip-content]");
 190                                 unzip(expected, tmpExpected);
 191                                 unzip(result, tmpResult);
 192                                 compareFiles(testCase, tmpExpected, tmpResult, null);
 193                         } else {
 194                                 List<String> expectedLines = Arrays.asList(IOUtils
 195                                                 .readSmallFile(expected).split("\n"));
 196                                 List<String> resultLines = Arrays.asList(IOUtils.readSmallFile(
 197                                                 result).split("\n"));
 198
 199                                 String name = expected.getAbsolutePath();
 200                                 if (name.startsWith(expectedDir.getAbsolutePath())) {
 201                                         name = expectedDir.getName()
 202                                                         + name.substring(expectedDir.getAbsolutePath()
 203                                                                         .length());
 204                                 }
 205                                 for (int j = 0; j < expectedLines.size(); j++) {
 206                                         String expectedLine = expectedLines.get(j);
 207                                         String resultLine = resultLines.get(j);
 208                                         if (name.endsWith(".info")
 209                                                         && expectedLine.startsWith("CREATION_DATE=")
 210                                                         && resultLine.startsWith("CREATION_DATE=")) {
 211                                                 // TODO: check the format?
 212                                                 continue;
 213                                         }
 214                                         testCase.assertEquals("Line " + (j + 1)
 215                                                         + " is not the same in file " + name, expectedLine,
 216                                                         resultLine);
 217                                 }
 218                         }
 219                 }
 220         }
 221
 222         private static void unzip(File zipFile, File targetDirectory)
 223                         throws IOException {
 224                 if (targetDirectory.exists() && targetDirectory.isFile()) {
 225                         throw new IOException("Cannot unzip " + zipFile + " into "
 226                                         + targetDirectory + ": it is not a directory");
 227                 }
 228
 229                 targetDirectory.mkdir();
 230                 if (!targetDirectory.exists()) {
 231                         throw new IOException("Cannot create target directory "
 232                                         + targetDirectory);
 233                 }
 234
 235                 FileInputStream in = new FileInputStream(zipFile);
 236                 try {
 237                         ZipInputStream zipStream = new ZipInputStream(in);
 238                         try {
 239                                 for (ZipEntry entry = zipStream.getNextEntry(); entry != null; entry = zipStream
 240                                                 .getNextEntry()) {
 241                                         File file = new File(targetDirectory, entry.getName());
 242                                         if (entry.isDirectory()) {
 243                                                 file.mkdirs();
 244                                         } else {
 245                                                 IOUtils.write(zipStream, file);
 246                                         }
 247                                 }
 248                         } finally {
 249                                 zipStream.close();
 250                         }
 251                 } finally {
 252                         in.close();
 253                 }
 254         }
 255 }