package org.jtheque.file;
import org.jtheque.core.Core;
import org.jtheque.file.FileService.XmlBackupVersion;
import org.jtheque.unit.AbstractJThequeTest;
import org.jtheque.utils.SystemProperty;
import org.jtheque.utils.bean.IntDate;
import org.jtheque.utils.bean.Version;
import org.jtheque.utils.io.FileException;
import org.jtheque.xml.utils.XML;
import org.jtheque.xml.utils.XMLException;
import org.jtheque.xml.utils.XMLReader;
import org.jtheque.xml.utils.XMLWriter;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import javax.annotation.Resource;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.concurrent.atomic.AtomicInteger;
import static org.junit.Assert.*;
/*
* Copyright JTheque (Baptiste Wicht)
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "jtheque-file-test.xml")
public class FileServiceTest extends AbstractJThequeTest {
@Resource
private FileService fileService;
@Test
public void initOK() {
assertNotNull(fileService);
}
@Test
public void exporters() {
final AtomicInteger counter = new AtomicInteger(0);
final Collection<String> datas = Arrays.asList("data1", "data2", "data3");
fileService.registerExporter("no-module", new Exporter<String>() {
@Override
public boolean canExportTo(String fileType) {
return "xml".equals(fileType);
}
@Override
public void export(String path, Collection<String> exportedDatas) throws FileException {
counter.incrementAndGet();
assertEquals("path", path);
assertEquals(datas, exportedDatas);
}
});
try {
fileService.exportDatas("no-module", "xml", "path", datas);
} catch (FileException e) {
fail("Exception during the export");
}
assertEquals(1, counter.get());
}
@Test
public void importers() {
final AtomicInteger counter = new AtomicInteger(0);
fileService.registerImporter("no-module", new Importer() {
@Override
public boolean canImportFrom(String fileType) {
return "xml".equals(fileType);
}
@Override
public void importFrom(String path) throws FileException {
assertEquals("path", path);
counter.incrementAndGet();
}
});
try {
fileService.importDatas("no-module", "xml", "path");
} catch (FileException e) {
fail("Exception during the export");
}
assertEquals(1, counter.get());
}
@Test
@DirtiesContext
public void restore() {
File backupFile = new File(SystemProperty.USER_DIR.get(), "backup.xml");
createFakeBackupFile(backupFile);
final AtomicInteger counter = new AtomicInteger(0);
fileService.registerBackuper("no-module", new ModuleBackuper() {
@Override
public String getId() {
return "test-backup";
}
@Override
public String[] getDependencies() {
return new String[0];
}
@Override
public ModuleBackup backup() {
fail("Backup must not be called");
return null;
}
@Override
public void restore(ModuleBackup backup) {
assertEquals("test-backup", backup.getId());
assertEquals(Version.get("1.0"), backup.getVersion());
assertEquals(1, backup.getNodes().size());
for (org.jtheque.xml.utils.Node node : backup.getNodes()) {
assertEquals("simple", node.getName());
assertEquals("true", node.getAttributeValue("test"));
}
counter.incrementAndGet();
}
});
try {
fileService.restore(backupFile);
} catch (XMLException e) {
fail(e.getMessage());
}
assertEquals(1, counter.get());
}
@Test
@DirtiesContext
public void backup() {
File restoreFile = new File(SystemProperty.USER_DIR.get(), "restore.xml");
fileService.registerBackuper("no-module", new ModuleBackuper() {
@Override
public String getId() {
return "test-backup";
}
@Override
public String[] getDependencies() {
return new String[0];
}
@Override
public ModuleBackup backup() {
Collection<org.jtheque.xml.utils.Node> nodes = new ArrayList<org.jtheque.xml.utils.Node>(1);
org.jtheque.xml.utils.Node node = new org.jtheque.xml.utils.Node("element");
node.setAttribute("test", "true");
nodes.add(node);
return new ModuleBackup(Version.get("1.0"), "test-backup", nodes);
}
@Override
public void restore(ModuleBackup backup) {
fail("Restore must not be called");
}
});
fileService.backup(restoreFile);
XMLReader<Node> reader = XML.newJavaFactory().newReader();
try {
reader.openFile(restoreFile);
} catch (XMLException e) {
fail(e.getMessage());
}
try {
Collection<Node> nodes = reader.getNodes("backup", reader.getRootElement());
assertEquals(1, nodes.size());
for (Node node : nodes) {
NodeList childrens = node.getChildNodes();
assertEquals("test-backup", getNode("id", childrens).getTextContent());
assertEquals("1.0", getNode("version", childrens).getTextContent());
Node nodesNode = getNode("nodes", childrens);
assertEquals("nodes", nodesNode.getNodeName());
childrens = nodesNode.getChildNodes();
Node elementNode = getNode("element", childrens);
assertEquals("element", elementNode.getNodeName());
assertEquals("true", elementNode.getAttributes().getNamedItem("test").getTextContent());
}
} catch (XMLException e) {
fail(e.getMessage());
}
try {
reader.close();
} catch (IOException e) {
fail(e.getMessage());
}
}
private static Node getNode(String name, NodeList childrens) {
for (int i = 0; i < childrens.getLength(); i++) {
if (name.equals(childrens.item(i).getNodeName())) {
return childrens.item(i);
}
}
return null;
}
private static void createFakeBackupFile(File file) {
XMLWriter<Node> writer = XML.newJavaFactory().newWriter("jtheque-backup");
writer.add("header");
writer.addOnly("date", Integer.toString(IntDate.today().intValue()));
writer.addOnly("file-version", Integer.toString(XmlBackupVersion.THIRD.ordinal()));
writer.addOnly("jtheque-version", Core.VERSION.getVersion());
writer.switchToParent();
addBackup(writer, "test-backup");
addBackup(writer, "test-backup-2");
writer.write(file.getAbsolutePath());
}
private static void addBackup(XMLWriter<Node> writer, String name) {
writer.add("backup");
writer.addOnly("id", name);
writer.addOnly("version", "1.0");
writer.add("nodes");
writer.add("simple");
writer.addAttribute("test", "true");
writer.switchToParent();
writer.switchToParent();
writer.switchToParent();
}
}