| /******************************************************************************* |
| * Copyright (c) 2010-2014 SAP AG and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * SAP AG - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.skalli.core.persistence; |
| |
| import static org.eclipse.skalli.testutil.StorageKey.keyOf; |
| import static org.hamcrest.Matchers.startsWith; |
| import static org.junit.Assert.*; |
| |
| import java.util.Calendar; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.SortedMap; |
| |
| import javax.xml.bind.DatatypeConverter; |
| |
| import org.apache.commons.lang.StringUtils; |
| import org.easymock.EasyMock; |
| import org.eclipse.skalli.commons.CollectionUtils; |
| import org.eclipse.skalli.commons.UUIDListConverter; |
| import org.eclipse.skalli.commons.XMLUtils; |
| import org.eclipse.skalli.core.xstream.ExtensionsMapConverter; |
| import org.eclipse.skalli.core.xstream.NoopConverter; |
| import org.eclipse.skalli.model.EntityBase; |
| import org.eclipse.skalli.services.extension.DataMigration; |
| import org.eclipse.skalli.testutil.HashMapStorageService; |
| import org.eclipse.skalli.testutil.StorageKey; |
| import org.eclipse.skalli.testutil.TestExtensibleEntityBase; |
| import org.eclipse.skalli.testutil.TestExtensibleEntityEntityService; |
| import org.eclipse.skalli.testutil.TestExtension; |
| import org.eclipse.skalli.testutil.TestExtension1; |
| import org.eclipse.skalli.testutil.TestUUIDs; |
| import org.junit.Test; |
| import org.w3c.dom.Attr; |
| import org.w3c.dom.Document; |
| import org.w3c.dom.Element; |
| |
| import com.thoughtworks.xstream.converters.Converter; |
| |
| @SuppressWarnings("nls") |
| public class XStreamPersistenceTest { |
| |
| private static final int CURRENT_MODEL_VERSION = 43; |
| |
| private static final String ALIAS_EXT1 = "ext1"; |
| private static final String ALIAS_EXT2 = "ext2"; |
| private static final String TIME0 = "2002-12-05T05:22:11Z"; |
| private static final String UPDATED_TIME0 = ">" + TIME0; |
| private static final String TIME1 = "2011-02-25T14:33:48"; |
| private static final String TIME2 = "2010-06-17T21:00:23Z"; |
| private static final String USER0 = "hugo"; |
| private static final String USER1 = "homer"; |
| private static final String USER2 = "marge"; |
| private static final String PERSIST_USER = "skalli"; |
| |
| private static final String ANY_XSD_TIME = "ANY_XSD_TIME"; |
| private static final String VALUE1 = "string"; |
| private static final String VALUE2 = "another_string"; |
| private static final String MODIFIED_VALUE = "modified_string"; |
| |
| private static final String[] ALIASES = { ALIAS_EXT1, ALIAS_EXT2 }; |
| private static final String[] VALUES = { VALUE1, VALUE2 }; |
| private static final String[] LAST_MODIFIED = { TIME1, TIME2 }; |
| private static final String[] LAST_MODIFIED_BY = { USER1, USER2 }; |
| |
| private static final String TEXT1 = "XStreamPersistenceTest greets the world!"; |
| |
| private static final String XML_WITH_VERSION = "<bla version=\"42\"><uuid>" + TestUUIDs.TEST_UUIDS[0] |
| + "</uuid><hello>world</hello><blubb>noop</blubb></bla>"; |
| private static final String XML_WITHOUT_VERSION = "<bla><uuid>" + TestUUIDs.TEST_UUIDS[0] |
| + "</uuid><hello>world</hello><blubb>noop</blubb></bla>"; |
| |
| private static final String XML_WITH_EXTENSIONS = createXML(TIME0, USER0, ALIASES, VALUES, |
| LAST_MODIFIED, LAST_MODIFIED_BY); |
| |
| |
| // XStreamPersistence instance under test backed by a HashMap-based storage service |
| private static class TestXStreamPersistence extends XStreamPersistence { |
| public TestXStreamPersistence() { |
| super(new HashMapStorageService()); |
| } |
| |
| private static StorageKey getStorageKey(TestExtensibleEntityBase entity) { |
| return keyOf(TestExtensibleEntityBase.class.getSimpleName(), |
| entity.getUuid().toString()); |
| } |
| |
| private byte[] getContentFromHashMap(TestExtensibleEntityBase entityKey) { |
| return ((HashMapStorageService) storageService).asMap().get(getStorageKey(entityKey)); |
| } |
| |
| private Document getDocumentFromHashMap(TestExtensibleEntityBase entityKey) throws Exception { |
| return XMLUtils.documentFromString(new String(getContentFromHashMap(entityKey), "UTF-8")); |
| } |
| } |
| |
| |
| @Test |
| public void testSaveLoadCycle() throws Exception { |
| TestExtensibleEntityBase entity = getExtensibleEntity(); |
| TestExtensibleEntityEntityService entityService = |
| new TestExtensibleEntityEntityService(CURRENT_MODEL_VERSION); |
| TestExtension ext1 = entity.getExtension(TestExtension.class); |
| ext1.setStr(TEXT1); |
| ext1.setBool(false); |
| |
| Map<String, Class<?>> aliases = getAliases(); |
| Set<Converter> converters = getConverters(); |
| |
| TestXStreamPersistence xp = new TestXStreamPersistence(); |
| |
| //saveEntity |
| Calendar beforeSaveDate = Calendar.getInstance(); |
| xp.saveEntity(entityService, entity, USER0, aliases, converters); |
| Calendar afterSaveDate = Calendar.getInstance(); |
| |
| //test that entity is now in the HashMap available and lastModified is set. |
| Document savedHashMapDoc = xp.getDocumentFromHashMap(entity); |
| String lastModified = xp.getLastModifiedAttribute(savedHashMapDoc.getDocumentElement()); |
| assertNotNull(lastModified); |
| assertIsXsdDateTime(lastModified); |
| Calendar lastModifiedDate = DatatypeConverter.parseDateTime(lastModified); |
| assertTrue(beforeSaveDate.compareTo(lastModifiedDate) <= 0); |
| assertTrue(lastModifiedDate.compareTo(afterSaveDate) <= 0); |
| |
| //test that lastModifiedDate is set for extensions as well |
| SortedMap<String, Element> extensions = xp.getExtensionsByAlias(savedHashMapDoc, aliases); |
| assertEquals(2, extensions.size()); |
| String lastModifiedExt1 = xp.getLastModifiedAttribute(extensions.get(ALIAS_EXT1)); |
| assertIsXsdDateTime(lastModifiedExt1); |
| String lastModifiedExt2 = xp.getLastModifiedAttribute(extensions.get(ALIAS_EXT1)); |
| assertIsXsdDateTime(lastModifiedExt2); |
| |
| //loadEntity again |
| Set<ClassLoader> entityClassLoaders = getTestExtensibleEntityBaseClassLodades(); |
| TestExtensibleEntityBase loadedEntity = xp.loadEntity(entityService, entity.getUuid().toString(), |
| entityClassLoaders, null, aliases, converters); |
| assertLoadedEntityIsExpectedOne(loadedEntity, USER0, USER0, USER0, lastModified, lastModifiedExt1, |
| lastModifiedExt2, TEXT1, false); |
| |
| // and check that loadEntities can read it |
| List<? extends TestExtensibleEntityBase> loadedEntities = xp.loadEntities(entityService, |
| entityClassLoaders, null, aliases, converters); |
| assertEquals(1, loadedEntities.size()); |
| assertLoadedEntityIsExpectedOne(loadedEntities.get(0), USER0, USER0, USER0, lastModified, lastModifiedExt1, |
| lastModifiedExt2, TEXT1, |
| false); |
| |
| //change the entity and save again |
| ext1 = entity.getExtension(TestExtension.class); |
| ext1.setStr(TEXT1 + " is now updated"); |
| xp.saveEntity(entityService, entity, USER1, aliases, converters); |
| |
| TestExtensibleEntityBase updatedEntity = xp.loadEntity(entityService, entity.getUuid().toString(), entityClassLoaders, |
| null, aliases, converters); |
| Document updatedHashMapDoc = xp.getDocumentFromHashMap(entity); |
| lastModified = xp.getLastModifiedAttribute(updatedHashMapDoc.getDocumentElement()); |
| SortedMap<String, Element> updatedExtensions = xp.getExtensionsByAlias(updatedHashMapDoc, |
| aliases); |
| lastModifiedExt1 = xp.getLastModifiedAttribute(updatedExtensions.get(ALIAS_EXT1)); |
| assertLoadedEntityIsExpectedOne(updatedEntity, USER1, USER1, USER0, lastModified, lastModifiedExt1, |
| lastModifiedExt2, TEXT1 + " is now updated", false); |
| } |
| |
| @Test |
| public void testPreProcessXML() throws Exception { |
| XStreamPersistence xp = new TestXStreamPersistence(); |
| DataMigration mockMigration = getMigrationMock(); |
| EasyMock.replay(mockMigration); |
| Document doc = XMLUtils.documentFromString(XML_WITH_VERSION); |
| xp.preProcessXML(doc, Collections.singleton(mockMigration), null, CURRENT_MODEL_VERSION); |
| String res = XMLUtils.documentToString(doc); |
| |
| // TODO: Insnt there something wrong here? |
| // isn't the expect version CURRENT_XSTREAM_PERSISTENCE_VERSION instead of the one out of the XML_WITH_VERSION=42 |
| String expected = "version=\"" + 42 + "\""; |
| assertTrue(res.contains(expected)); |
| EasyMock.verify(mockMigration); |
| } |
| |
| @Test |
| public void testPostProcessEntity() throws Exception { |
| Document doc = XMLUtils.documentFromString(XML_WITH_EXTENSIONS); |
| Map<String, Class<?>> aliases = getAliases(); |
| TestExtensibleEntityBase entity = getExtensibleEntity(); |
| XStreamPersistence xp = new TestXStreamPersistence(); |
| xp.postProcessEntity(doc, entity, aliases); |
| assertEquals(TIME0, entity.getLastModified()); |
| assertEquals(USER0, entity.getLastModifiedBy()); |
| TestExtension ext1 = entity.getExtension(TestExtension.class); |
| assertNotNull(ext1); |
| assertEquals(TIME1, ext1.getLastModified()); |
| assertEquals(USER1, ext1.getLastModifiedBy()); |
| TestExtension ext2 = entity.getExtension(TestExtension1.class); |
| assertNotNull(ext2); |
| assertEquals(TIME2, ext2.getLastModified()); |
| assertEquals(USER2, ext2.getLastModifiedBy()); |
| } |
| |
| @Test |
| public void testPostProcessXMLUnmodifiedDocument() throws Exception { |
| Document doc = XMLUtils.documentFromString(XML_WITH_EXTENSIONS); |
| assertPostProcessedXML(doc, doc, PERSIST_USER, TIME0, USER0, ALIASES, LAST_MODIFIED, LAST_MODIFIED_BY); |
| |
| // test initialization of missing lastModified and lastModifiedBy attributes |
| doc = XMLUtils.documentFromString(createXML(null, null, ALIASES, VALUES, |
| new String[] { null, null }, new String[] { null, null })); |
| assertPostProcessedXML(doc, doc, PERSIST_USER, ANY_XSD_TIME, PERSIST_USER, ALIASES, |
| new String[] { ANY_XSD_TIME, ANY_XSD_TIME }, new String[] { PERSIST_USER, PERSIST_USER }); |
| |
| // test initialization of missing lastModified attributes |
| doc = XMLUtils.documentFromString(createXML(TIME0, USER0, ALIASES, VALUES, |
| new String[] { null, null }, LAST_MODIFIED_BY)); |
| assertPostProcessedXML(doc, doc, PERSIST_USER, TIME0, USER0, ALIASES, |
| new String[] { ANY_XSD_TIME, ANY_XSD_TIME }, LAST_MODIFIED_BY); |
| |
| doc = XMLUtils.documentFromString(createXML(null, USER0, ALIASES, VALUES, |
| new String[] { TIME1, null }, LAST_MODIFIED_BY)); |
| assertPostProcessedXML(doc, doc, PERSIST_USER, ANY_XSD_TIME, USER0, ALIASES, |
| new String[] { TIME1, ANY_XSD_TIME }, LAST_MODIFIED_BY); |
| |
| doc = XMLUtils.documentFromString(createXML(null, USER0, ALIASES, VALUES, |
| new String[] { null, TIME2 }, LAST_MODIFIED_BY)); |
| assertPostProcessedXML(doc, doc, PERSIST_USER, ANY_XSD_TIME, USER0, ALIASES, |
| new String[] { ANY_XSD_TIME, TIME2 }, LAST_MODIFIED_BY); |
| |
| // test initialization of missing lastModifiedBy attributes |
| doc = XMLUtils.documentFromString(createXML(TIME0, null, ALIASES, VALUES, LAST_MODIFIED, |
| new String[] { null, null })); |
| assertPostProcessedXML(doc, doc, PERSIST_USER, TIME0, PERSIST_USER, ALIASES, |
| LAST_MODIFIED, new String[] { PERSIST_USER, PERSIST_USER }); |
| |
| doc = XMLUtils.documentFromString(createXML(TIME0, USER1, ALIASES, VALUES, LAST_MODIFIED, |
| new String[] { null, null })); |
| assertPostProcessedXML(doc, doc, PERSIST_USER, TIME0, USER1, ALIASES, |
| LAST_MODIFIED, new String[] { PERSIST_USER, PERSIST_USER }); |
| |
| doc = XMLUtils.documentFromString(createXML(TIME0, null, ALIASES, VALUES, LAST_MODIFIED, |
| new String[] { USER1, null })); |
| assertPostProcessedXML(doc, doc, PERSIST_USER, TIME0, PERSIST_USER, ALIASES, |
| LAST_MODIFIED, new String[] { USER1, PERSIST_USER }); |
| |
| doc = XMLUtils.documentFromString(createXML(TIME0, null, ALIASES, VALUES, LAST_MODIFIED, |
| new String[] { null, USER1 })); |
| assertPostProcessedXML(doc, doc, PERSIST_USER, TIME0, PERSIST_USER, ALIASES, |
| LAST_MODIFIED, new String[] { PERSIST_USER, USER1 }); |
| } |
| |
| @Test |
| public void testPostProcessXMLModifiedExtension() throws Exception { |
| Document oldDoc = XMLUtils.documentFromString(createXML(TIME0, USER0, ALIASES, |
| new String[] { VALUE1, VALUE2 }, LAST_MODIFIED, LAST_MODIFIED_BY)); |
| Document newDoc = XMLUtils.documentFromString(createXML(null, null, ALIASES, |
| new String[] { MODIFIED_VALUE, VALUE2 }, new String[] { null, null }, new String[] { null, null })); |
| assertPostProcessedXML(newDoc, oldDoc, PERSIST_USER, UPDATED_TIME0, PERSIST_USER, ALIASES, |
| new String[] { UPDATED_TIME0, TIME2 }, new String[] { PERSIST_USER, USER2 }); |
| |
| // test initialization of missing lastModified and lastModifiedBy attributes |
| oldDoc = XMLUtils.documentFromString(createXML(null, null, ALIASES, |
| new String[] { VALUE1, VALUE2 }, new String[] { null, null }, new String[] { null, null })); |
| newDoc = XMLUtils.documentFromString(createXML(null, null, ALIASES, |
| new String[] { MODIFIED_VALUE, VALUE2 }, new String[] { null, null }, new String[] { null, null })); |
| assertPostProcessedXML(newDoc, oldDoc, PERSIST_USER, ANY_XSD_TIME, PERSIST_USER, ALIASES, |
| new String[] { ANY_XSD_TIME, ANY_XSD_TIME }, new String[] { PERSIST_USER, PERSIST_USER }); |
| |
| // test initialization of missing lastModified attributes |
| oldDoc = XMLUtils.documentFromString(createXML(TIME0, USER0, ALIASES, |
| new String[] { VALUE1, VALUE2 }, new String[] { null, null }, LAST_MODIFIED_BY)); |
| newDoc = XMLUtils.documentFromString(createXML(null, null, ALIASES, |
| new String[] { MODIFIED_VALUE, VALUE2 }, new String[] { null, null }, new String[] { null, null })); |
| assertPostProcessedXML(newDoc, oldDoc, PERSIST_USER, UPDATED_TIME0, PERSIST_USER, ALIASES, |
| new String[] { UPDATED_TIME0, ANY_XSD_TIME }, new String[] { PERSIST_USER, USER2 }); |
| |
| oldDoc = XMLUtils.documentFromString(createXML(null, USER0, ALIASES, |
| new String[] { VALUE1, VALUE2 }, new String[] { TIME0, null }, LAST_MODIFIED_BY)); |
| newDoc = XMLUtils.documentFromString(createXML(null, null, ALIASES, |
| new String[] { MODIFIED_VALUE, VALUE2 }, new String[] { null, null }, new String[] { null, null })); |
| assertPostProcessedXML(newDoc, oldDoc, PERSIST_USER, UPDATED_TIME0, PERSIST_USER, ALIASES, |
| new String[] { UPDATED_TIME0, ANY_XSD_TIME }, new String[] { PERSIST_USER, USER2 }); |
| |
| oldDoc = XMLUtils.documentFromString(createXML(null, USER0, ALIASES, |
| new String[] { VALUE1, VALUE2 }, new String[] { null, TIME0 }, LAST_MODIFIED_BY)); |
| newDoc = XMLUtils.documentFromString(createXML(null, null, ALIASES, |
| new String[] { MODIFIED_VALUE, VALUE2 }, new String[] { null, null }, new String[] { null, null })); |
| assertPostProcessedXML(newDoc, oldDoc, PERSIST_USER, UPDATED_TIME0, PERSIST_USER, ALIASES, |
| new String[] { UPDATED_TIME0, TIME0 }, new String[] { PERSIST_USER, USER2 }); |
| |
| // test initialization of missing lastModifiedBy attributes |
| oldDoc = XMLUtils.documentFromString(createXML(TIME0, null, ALIASES, |
| new String[] { VALUE1, VALUE2 }, LAST_MODIFIED, new String[] { null, null })); |
| newDoc = XMLUtils.documentFromString(createXML(null, null, ALIASES, |
| new String[] { MODIFIED_VALUE, VALUE2 }, new String[] { null, null }, new String[] { null, null })); |
| assertPostProcessedXML(newDoc, oldDoc, PERSIST_USER, UPDATED_TIME0, PERSIST_USER, ALIASES, |
| new String[] { UPDATED_TIME0, TIME2 }, new String[] { PERSIST_USER, PERSIST_USER }); |
| |
| oldDoc = XMLUtils.documentFromString(createXML(TIME0, null, ALIASES, |
| new String[] { VALUE1, VALUE2 }, LAST_MODIFIED, new String[] { USER0, null })); |
| newDoc = XMLUtils.documentFromString(createXML(null, null, ALIASES, |
| new String[] { MODIFIED_VALUE, VALUE2 }, new String[] { null, null }, new String[] { null, null })); |
| assertPostProcessedXML(newDoc, oldDoc, PERSIST_USER, UPDATED_TIME0, PERSIST_USER, ALIASES, |
| new String[] { UPDATED_TIME0, TIME2 }, new String[] { PERSIST_USER, PERSIST_USER }); |
| |
| oldDoc = XMLUtils.documentFromString(createXML(TIME0, null, ALIASES, |
| new String[] { VALUE1, VALUE2 }, LAST_MODIFIED, new String[] { null, USER0 })); |
| newDoc = XMLUtils.documentFromString(createXML(null, null, ALIASES, |
| new String[] { MODIFIED_VALUE, VALUE2 }, new String[] { null, null }, new String[] { null, null })); |
| assertPostProcessedXML(newDoc, oldDoc, PERSIST_USER, UPDATED_TIME0, PERSIST_USER, ALIASES, |
| new String[] { UPDATED_TIME0, TIME2 }, new String[] { PERSIST_USER, USER0 }); |
| } |
| |
| @Test |
| public void testGetExtensionsByAlias() throws Exception { |
| Document doc = XMLUtils.documentFromString(XML_WITH_EXTENSIONS); |
| Map<String, Class<?>> aliases = getAliases(); |
| XStreamPersistence xp = new TestXStreamPersistence(); |
| SortedMap<String, Element> extensions = xp.getExtensionsByAlias(doc, aliases); |
| assertEquals(2, extensions.size()); |
| for (String alias : extensions.keySet()) { |
| assertTrue(aliases.containsKey(alias)); |
| assertEquals(alias, extensions.get(alias).getNodeName()); |
| } |
| |
| //check that the content of ext1 is the expected one |
| assertEquals("string", extensions.get("ext1").getFirstChild().getNodeName()); |
| assertEquals("string", extensions.get("ext1").getFirstChild().getTextContent()); |
| } |
| |
| @Test |
| public void testGetExtensionsByClassName() throws Exception { |
| XStreamPersistence xp = new TestXStreamPersistence(); |
| Document doc = XMLUtils.documentFromString(XML_WITH_EXTENSIONS); |
| Map<String, Class<?>> aliases = getAliases(); |
| SortedMap<String, Element> extensions = xp.getExtensionsByClassName(doc, aliases); |
| assertEquals(2, extensions.size()); |
| for (String alias : aliases.keySet()) { |
| String className = aliases.get(alias).getName(); |
| assertTrue(extensions.containsKey(className)); |
| assertEquals(alias, extensions.get(className).getNodeName()); |
| } |
| } |
| |
| @Test |
| public void testGetExtensionsNoMatchingAliases() throws Exception { |
| XStreamPersistence xp = new TestXStreamPersistence(); |
| Document doc = XMLUtils.documentFromString(XML_WITH_EXTENSIONS); |
| Map<String, Class<?>> notMatchingAliases = getNotMatchingAliases(); |
| SortedMap<String, Element> extensions = xp.getExtensionsByAlias(doc, notMatchingAliases); |
| assertNotNull(extensions); |
| assertTrue(extensions.isEmpty()); |
| extensions = xp.getExtensionsByClassName(doc, notMatchingAliases); |
| assertNotNull(extensions); |
| assertTrue(extensions.isEmpty()); |
| } |
| |
| @Test |
| public void testVersionAttribute() throws Exception { |
| XStreamPersistence xp = new TestXStreamPersistence(); |
| assertEquals(0, xp.getVersionAttribute(XMLUtils.documentFromString(XML_WITHOUT_VERSION))); |
| assertEquals(42, xp.getVersionAttribute(XMLUtils.documentFromString(XML_WITH_VERSION))); |
| } |
| |
| @Test |
| public void testSetVersionAttribute() throws Exception { |
| XStreamPersistence xp = new TestXStreamPersistence(); |
| Document doc = XMLUtils.documentFromString(XML_WITHOUT_VERSION); |
| xp.setVersionAttribute(doc, CURRENT_MODEL_VERSION); |
| assertEquals(CURRENT_MODEL_VERSION, xp.getVersionAttribute(doc)); |
| } |
| |
| @Test |
| public void testSetLastModifiedAttribute() throws Exception { |
| XStreamPersistence xp = new TestXStreamPersistence(); |
| Element element = XMLUtils.documentFromString("<dummy></dummy>").getDocumentElement(); |
| xp.setLastModifiedAttribute(element); |
| Attr lastMod = element.getAttributeNode("lastModified"); |
| assertIsXsdDateTime(lastMod.getTextContent()); |
| } |
| |
| @Test |
| public void testCallSetVersionAttributeTwice() throws Exception { |
| XStreamPersistence xp = new TestXStreamPersistence(); |
| Document doc = XMLUtils.documentFromString(XML_WITHOUT_VERSION); |
| xp.setVersionAttribute(doc, CURRENT_MODEL_VERSION); |
| try { |
| xp.setVersionAttribute(doc, CURRENT_MODEL_VERSION); |
| } catch (RuntimeException e) { |
| assertTrue(e.getMessage().contains("element already has a 'version' attribute")); |
| } |
| } |
| |
| @Test |
| public void testLastModified() throws Exception { |
| XStreamPersistence xp = new TestXStreamPersistence(); |
| Document doc = XMLUtils.documentFromString(XML_WITHOUT_VERSION); |
| Element documentElement = doc.getDocumentElement(); |
| xp.setLastModifiedAttribute(documentElement); |
| assertIsXsdDateTime(xp.getLastModifiedAttribute(documentElement)); |
| } |
| |
| @Test |
| public void testLastModifiedBy() throws Exception { |
| XStreamPersistence xp = new TestXStreamPersistence(); |
| Document doc = XMLUtils.documentFromString(XML_WITHOUT_VERSION); |
| Element documentElement = doc.getDocumentElement(); |
| xp.setLastModifiedByAttribute(documentElement, USER0); |
| assertEquals(USER0, xp.getLastModifiedByAttribute(documentElement)); |
| } |
| |
| @Test |
| public void testNonIdenticalElements() throws Exception { |
| XStreamPersistence xp = new TestXStreamPersistence(); |
| Document doc = XMLUtils.documentFromString(XML_WITH_EXTENSIONS); |
| Element documentElement = doc.getDocumentElement(); |
| Map<String, Class<?>> aliases = getAliases(); |
| SortedMap<String, Element> extensions = xp.getExtensionsByClassName(doc, aliases); |
| assertTrue(extensions.size() > 0); |
| for (Element element : extensions.values()) { |
| assertFalse(XMLDiff.identical(documentElement, element)); |
| } |
| } |
| |
| @Test |
| public void testIdenticalWithNullParams() throws Exception { |
| Document doc = XMLUtils.documentFromString(XML_WITHOUT_VERSION); |
| Element documentElement = doc.getDocumentElement(); |
| assertTrue(XMLDiff.identical(null, null)); |
| assertFalse(XMLDiff.identical(null, documentElement)); |
| assertFalse(XMLDiff.identical(documentElement, null)); |
| assertTrue(XMLDiff.identical(documentElement, documentElement)); |
| } |
| |
| private void assertPostProcessedXML(Document newDoc, Document oldDoc, String userId, |
| String expectedGlobalLastModified, String expectedGlobalLastModifiedBy, String[] expectedAliases, |
| String[] expectedExtLastModified, String[] expectedExtLastModifiedBy) throws Exception { |
| XStreamPersistence xp = new TestXStreamPersistence(); |
| Map<String, Class<?>> aliases = getAliases(); |
| xp.postProcessXML(newDoc, oldDoc, aliases, userId, CURRENT_MODEL_VERSION); |
| Element documentElement = newDoc.getDocumentElement(); |
| assertLastModifiedTime(expectedGlobalLastModified, xp.getLastModifiedAttribute(documentElement)); |
| assertEquals(expectedGlobalLastModifiedBy, xp.getLastModifiedByAttribute(documentElement)); |
| SortedMap<String, Element> extensions = xp.getExtensionsByAlias(newDoc, aliases); |
| int i = 0; |
| for (Element ext: extensions.values()) { |
| assertEquals(expectedAliases[i], ext.getNodeName()); |
| assertLastModifiedTime(expectedExtLastModified[i], xp.getLastModifiedAttribute(ext)); |
| assertEquals(expectedExtLastModifiedBy[i], xp.getLastModifiedByAttribute(ext)); |
| ++i; |
| } |
| assertEquals(CURRENT_MODEL_VERSION, xp.getVersionAttribute(newDoc)); |
| } |
| |
| private void assertLastModifiedTime(String expected, String actual) { |
| if (ANY_XSD_TIME.equals(expected)) { |
| assertIsXsdDateTime(actual); |
| } else if (expected.startsWith(">")) { |
| assertIsXsdDateTime(actual); |
| long actualMillis = DatatypeConverter.parseDateTime(actual).getTimeInMillis(); |
| long expectedMillis = DatatypeConverter.parseDateTime(expected.substring(1)).getTimeInMillis(); |
| assertTrue(actualMillis > expectedMillis); |
| } else { |
| assertEquals(actual, expected); |
| } |
| } |
| |
| private void assertIsXsdDateTime(String lexicalXSDDateTime) { |
| assertTrue(StringUtils.isNotBlank(lexicalXSDDateTime)); |
| DatatypeConverter.parseDateTime(lexicalXSDDateTime); |
| } |
| |
| //checks that within a range of seconds the dateString matches the expectedDateString |
| private void assertLastModifiedDate(String dateString, String expectedDateString) { |
| assertThat(dateString, startsWith(expectedDateString.substring(0, "YYYY-MM-DDTHH:MM:SS".length()))); |
| } |
| |
| private void assertLoadedEntityIsExpectedOne(TestExtensibleEntityBase loadedEntity, |
| String user, String userExt1, String userExt2, |
| String lastModified, String lastModifiedExt1, String lastModifiedExt2, |
| String ext1Text, boolean ext1boolean) { |
| assertNotNull(loadedEntity); |
| assertLastModifiedDate(loadedEntity.getLastModified(), lastModified); |
| assertEquals(user, loadedEntity.getLastModifiedBy()); |
| TestExtension ext1 = ((TestExtensibleEntityBase) loadedEntity).getExtension(TestExtension.class); |
| assertNotNull(ext1); |
| assertLastModifiedDate(ext1.getLastModified(), lastModifiedExt1); |
| assertEquals(ext1Text, ext1.getStr()); |
| assertEquals(ext1boolean, ext1.isBool()); |
| assertEquals(userExt1, ext1.getLastModifiedBy()); |
| TestExtension1 ext2 = ((TestExtensibleEntityBase) loadedEntity).getExtension(TestExtension1.class); |
| assertNotNull(ext2); |
| assertLastModifiedDate(ext2.getLastModified(), lastModifiedExt2); |
| } |
| |
| private Map<String, Class<?>> getAliases() { |
| Map<String, Class<?>> aliases = new HashMap<String, Class<?>>(); |
| aliases.put(ALIAS_EXT1, TestExtension.class); |
| aliases.put(ALIAS_EXT2, TestExtension1.class); |
| return aliases; |
| } |
| |
| private <T extends EntityBase> Set<Converter> getConverters() { |
| return CollectionUtils.asSet(new NoopConverter(), new UUIDListConverter(), new ExtensionsMapConverter()); |
| } |
| |
| private Set<ClassLoader> getTestExtensibleEntityBaseClassLodades() { |
| Set<ClassLoader> entityClassLoaders = new HashSet<ClassLoader>(); |
| entityClassLoaders.add(TestExtensibleEntityBase.class.getClassLoader()); |
| entityClassLoaders.add(TestExtension.class.getClassLoader()); |
| entityClassLoaders.add(TestExtension1.class.getClassLoader()); |
| return entityClassLoaders; |
| } |
| |
| private Map<String, Class<?>> getNotMatchingAliases() { |
| Map<String, Class<?>> aliases = new HashMap<String, Class<?>>(); |
| aliases.put("notext1", TestExtension.class); |
| aliases.put("notext2", TestExtension1.class); |
| return aliases; |
| } |
| |
| private TestExtensibleEntityBase getExtensibleEntity() { |
| TestExtensibleEntityBase entity = new TestExtensibleEntityBase(TestUUIDs.TEST_UUIDS[0]); |
| entity.addExtension(new TestExtension()); |
| entity.addExtension(new TestExtension1()); |
| return entity; |
| } |
| |
| private DataMigration getMigrationMock() throws Exception { |
| DataMigration mockMigration = EasyMock.createMock(DataMigration.class); |
| EasyMock.reset(mockMigration); |
| mockMigration.handlesType(EasyMock.isA(String.class)); |
| EasyMock.expectLastCall().andReturn(true).anyTimes(); |
| mockMigration.getFromVersion(); |
| EasyMock.expectLastCall().andReturn(42).anyTimes(); |
| mockMigration.migrate(EasyMock.isA(Document.class)); |
| EasyMock.expectLastCall(); |
| return mockMigration; |
| } |
| |
| private static String createXML(String docLastModified, String docLastModifiedBy, |
| String[] aliases, String[] values, String[] extLastModified, String[] extLastModifiedBy) { |
| StringBuilder sb = new StringBuilder(); |
| sb.append("<root"); |
| appendModifiedAttributes(sb, docLastModified, docLastModifiedBy); |
| sb.append(">"); |
| if (aliases != null) { |
| sb.append("<extensions>"); |
| for (int i = 0; i < aliases.length; ++i) { |
| sb.append("<").append(aliases[i]); |
| appendModifiedAttributes(sb, extLastModified[i], extLastModifiedBy[i]); |
| sb.append(">"); |
| if (values[i] != null) { |
| sb.append("<string>").append(values[i]).append("</string>"); |
| } |
| sb.append("</").append(aliases[i]).append(">"); |
| } |
| sb.append("</extensions>"); |
| } |
| sb.append("</root>"); |
| return sb.toString(); |
| } |
| |
| private static void appendModifiedAttributes(StringBuilder sb, String lastModified, String lastModifiedBy) { |
| if (lastModified != null) { |
| sb.append(" lastModified=\"").append(lastModified).append("\""); |
| } |
| if (lastModifiedBy != null) { |
| sb.append(" modifiedBy=\"").append(lastModifiedBy).append("\""); |
| } |
| } |
| } |
