| /******************************************************************************* |
| * 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 java.util.ArrayList; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.UUID; |
| |
| import org.eclipse.skalli.commons.CollectionUtils; |
| import org.eclipse.skalli.commons.XMLUtils; |
| import org.eclipse.skalli.model.EntityBase; |
| import org.eclipse.skalli.model.ExtensibleEntityBase; |
| import org.eclipse.skalli.model.ExtensionEntityBase; |
| import org.eclipse.skalli.services.entity.EntityService; |
| import org.eclipse.skalli.services.extension.ExtensionService; |
| import org.eclipse.skalli.testutil.AssertUtils; |
| import org.eclipse.skalli.testutil.BundleManager; |
| import org.eclipse.skalli.testutil.HashMapStorageService; |
| import org.eclipse.skalli.testutil.TestEntityBase; |
| import org.eclipse.skalli.testutil.TestExtensibleEntityBase; |
| import org.eclipse.skalli.testutil.TestExtensibleEntityEntityService; |
| import org.eclipse.skalli.testutil.TestExtensibleEntityExtensionService; |
| import org.eclipse.skalli.testutil.TestExtension; |
| import org.eclipse.skalli.testutil.TestExtension1; |
| import org.eclipse.skalli.testutil.TestUUIDs; |
| import org.junit.After; |
| import org.junit.Assert; |
| import org.junit.Before; |
| import org.junit.Test; |
| import org.osgi.framework.ServiceRegistration; |
| import org.w3c.dom.Document; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.Node; |
| import org.w3c.dom.NodeList; |
| |
| @SuppressWarnings("nls") |
| public class XStreamPersistenceComponentTest { |
| |
| private XStreamPersistenceComponent persistenceService; |
| private HashMapStorageService hashMapStorageService; |
| |
| private TestEntityBase parent1; |
| private TestEntityBase parent2; |
| private TestEntityBase entity1; |
| private TestEntityBase entity2; |
| private TestEntityBase entity3; |
| private TestEntityBase entity4; |
| private TestEntityBase entity5; |
| private TestEntityBase entity6; |
| private TestEntityBase entity7; |
| |
| private List<ServiceRegistration<?>> serviceRegistrations = new ArrayList<ServiceRegistration<?>>(); |
| |
| @Before |
| public void setup() throws Exception { |
| serviceRegistrations.add(BundleManager.registerService(ExtensionService.class, |
| new TestExtensibleEntityExtensionService(), null)); |
| serviceRegistrations.add(BundleManager.registerService(EntityService.class, |
| new TestExtensibleEntityEntityService(0), null)); |
| Assert.assertEquals(2, serviceRegistrations.size()); |
| hashMapStorageService = new HashMapStorageService(); |
| persistenceService = new XStreamPersistenceComponent(hashMapStorageService); |
| |
| parent1 = new TestEntityBase(TestUUIDs.TEST_UUIDS[0]); |
| parent2 = new TestEntityBase(TestUUIDs.TEST_UUIDS[1]); |
| parent2.setDeleted(true); |
| |
| // non-deleted entities referencing non-deleted parent entities |
| // hierarchy: entity2 -> entity1 -> parent1 |
| entity1 = new TestEntityBase(TestUUIDs.TEST_UUIDS[2], TestUUIDs.TEST_UUIDS[0]); |
| entity2 = new TestEntityBase(TestUUIDs.TEST_UUIDS[3], TestUUIDs.TEST_UUIDS[2]); |
| |
| // non-deleted entity referencing a deleted parent entity |
| entity3 = new TestEntityBase(TestUUIDs.TEST_UUIDS[4], TestUUIDs.TEST_UUIDS[1]); |
| |
| // deleted entity referencing a deleted parent entity |
| entity4 = new TestEntityBase(TestUUIDs.TEST_UUIDS[5], TestUUIDs.TEST_UUIDS[1]); |
| entity4.setDeleted(true); |
| |
| // deleted entity referencing a non-deleted parent entity |
| entity5 = new TestEntityBase(TestUUIDs.TEST_UUIDS[6], TestUUIDs.TEST_UUIDS[0]); |
| entity5.setDeleted(true); |
| |
| // siblings of entity1 |
| entity6 = new TestEntityBase(TestUUIDs.TEST_UUIDS[7], TestUUIDs.TEST_UUIDS[0]); |
| entity7 = new TestEntityBase(TestUUIDs.TEST_UUIDS[8], TestUUIDs.TEST_UUIDS[0]); |
| } |
| |
| @After |
| public void tearDown() { |
| for (ServiceRegistration<?> serviceRegistration : serviceRegistrations) { |
| serviceRegistration.unregister(); |
| } |
| } |
| |
| @Test |
| public void testPersistAndLoad() throws Exception { |
| // create and persist test entities |
| List<TestExtensibleEntityBase> expectedEntities = createTestEntityHierarchy(); |
| for (ExtensibleEntityBase entity : expectedEntities) { |
| persistenceService.persist(entity.getClass(), entity, "anyonomous"); |
| } |
| |
| // read the persisted files as DOM and do some asserts |
| for (TestExtensibleEntityBase entity : expectedEntities) { |
| Assert.assertNotNull(entity); |
| |
| byte[] blob = hashMapStorageService.asMap().get( |
| keyOf(entity.getClass().getSimpleName(), entity.getUuid().toString())); |
| Document doc = XMLUtils.documentFromString(new String(blob, "UTF-8")); |
| |
| // check that the extensible entity has been persisted with its default alias |
| // and check some nodes (uuid, extensions etc.) |
| NodeList nodes = doc.getElementsByTagName("entity-foobar"); |
| Assert.assertEquals(1, nodes.getLength()); |
| nodes = ((Element)nodes.item(0)).getChildNodes(); |
| for (int i = 0; i < nodes.getLength(); ++i) { |
| assertNode(nodes.item(i), entity); |
| } |
| } |
| |
| // create a new instance for loading of persisted entities |
| List<TestExtensibleEntityBase> actualEntities = persistenceService.getEntities(TestExtensibleEntityBase.class); |
| List<TestExtensibleEntityBase> actualDeletedEntities = persistenceService.getDeletedEntities(TestExtensibleEntityBase.class); |
| Assert.assertEquals(3, actualEntities.size()); |
| Assert.assertEquals(2, actualDeletedEntities.size()); |
| |
| // assert that unmarshalled entities equal the original entities |
| // see assertEquals() methods in TestExtensibleEntityBase and TestExtension |
| for (TestExtensibleEntityBase actualEntity : actualEntities) { |
| UUID uuid = actualEntity.getUuid(); |
| boolean found = false; |
| for (TestExtensibleEntityBase expected : expectedEntities) { |
| if (expected.getUuid().equals(uuid)) { |
| TestExtensibleEntityBase.assertEquals(expected, actualEntity); |
| found = true; |
| } |
| } |
| if (!found) { |
| Assert.fail("Should have been found"); |
| } |
| } |
| } |
| |
| @Test |
| public void testPersistLoadPersistCycle() throws Exception { |
| List<TestExtensibleEntityBase> expectedEntities = createTestEntityHierarchy(); |
| for (ExtensibleEntityBase entity : expectedEntities) { |
| persistenceService.persist(entity.getClass(), entity, "anyonomous"); |
| } |
| |
| // load a project with a parent and a child |
| TestExtensibleEntityBase parent = |
| persistenceService.loadEntity(TestExtensibleEntityBase.class, TestUUIDs.TEST_UUIDS[1]); |
| // ensure that it has no parent |
| Assert.assertEquals(TestUUIDs.TEST_UUIDS[2], parent.getParentEntityId()); |
| Assert.assertEquals(TestUUIDs.TEST_UUIDS[2], parent.getParentEntity().getUuid()); |
| // ensure that the children have not been reseolved |
| Assert.assertNull(parent.getFirstChild()); |
| |
| // save the loaded entity again |
| persistenceService.persist(TestExtensibleEntityBase.class, parent, "anonymous"); |
| |
| // ensure we still have the same parent |
| Assert.assertEquals(TestUUIDs.TEST_UUIDS[2], parent.getParentEntityId()); |
| Assert.assertEquals(TestUUIDs.TEST_UUIDS[2], parent.getParentEntity().getUuid()); |
| // ensure that the children have now been resolved! |
| Assert.assertNotNull(parent.getFirstChild()); |
| Assert.assertEquals(TestUUIDs.TEST_UUIDS[0], parent.getFirstChild().getUuid()); |
| } |
| |
| @Test(expected = RuntimeException.class) |
| public void testPersistUnknownParent() throws Exception { |
| List<TestExtensibleEntityBase> expectedEntities = createTestEntityHierarchy(); |
| TestExtensibleEntityBase entity = expectedEntities.get(1); |
| persistenceService.persist(entity.getClass(), entity, "anonymous"); |
| } |
| |
| @Test |
| public void testResolveEntityRelations() throws Exception { |
| XStreamPersistenceComponent p = new XStreamPersistenceComponent(); |
| p.registerEntityClass(TestEntityBase.class); |
| |
| // insert all the entities and calculate the relations |
| updateCache(p, parent1, parent2, entity1, entity2, entity3, entity4, entity5, entity6, entity7); |
| p.resolveEntityRelations(TestEntityBase.class); |
| |
| // assert that the caches contain the expected entities |
| AssertUtils.assertEqualsAnyOrder("keySet()", |
| CollectionUtils.asSet(TestUUIDs.TEST_UUIDS[0], TestUUIDs.TEST_UUIDS[2], TestUUIDs.TEST_UUIDS[3], |
| TestUUIDs.TEST_UUIDS[4], TestUUIDs.TEST_UUIDS[7], TestUUIDs.TEST_UUIDS[8]), |
| p.keySet(TestEntityBase.class)); |
| AssertUtils.assertEqualsAnyOrder("deletedSet()", |
| CollectionUtils.asSet(TestUUIDs.TEST_UUIDS[1], TestUUIDs.TEST_UUIDS[5], TestUUIDs.TEST_UUIDS[6]), |
| p.deletedSet(TestEntityBase.class)); |
| |
| // assert the parent and siblings pointers |
| TestEntityBase testEntity = p.getEntity(TestEntityBase.class, TestUUIDs.TEST_UUIDS[0]); |
| TestEntityBase.assertEquals(parent1, testEntity); |
| Assert.assertNull(testEntity.getParentEntity()); |
| Assert.assertNull(testEntity.getNextSibling()); |
| TestEntityBase.assertEquals(entity6, testEntity.getFirstChild()); |
| TestEntityBase.assertEquals(entity1, entity6.getNextSibling()); |
| TestEntityBase.assertEquals(entity2, entity1.getFirstChild()); |
| TestEntityBase.assertEquals(entity7, entity1.getNextSibling()); |
| Assert.assertNull(entity7.getNextSibling()); |
| TestEntityBase.assertEquals(parent1, p.getEntity(TestEntityBase.class, TestUUIDs.TEST_UUIDS[2]).getParentEntity()); |
| TestEntityBase.assertEquals(entity1, p.getEntity(TestEntityBase.class, TestUUIDs.TEST_UUIDS[3]).getParentEntity()); |
| Assert.assertNull(p.getDeletedEntity(TestEntityBase.class, TestUUIDs.TEST_UUIDS[1]).getParentEntity()); |
| |
| // non-deleted entity MUST NOT reference a deleted parent entity: |
| Assert.assertNull(p.getEntity(TestEntityBase.class, TestUUIDs.TEST_UUIDS[4]).getParentEntity()); |
| |
| // deleted entity MAY reference a deleted parent entity |
| TestEntityBase.assertEquals(parent2, p.getDeletedEntity(TestEntityBase.class, TestUUIDs.TEST_UUIDS[5]).getParentEntity()); |
| |
| // deleted entity MAY reference a non-deleted parent entity |
| TestEntityBase.assertEquals(parent1, p.getDeletedEntity(TestEntityBase.class, TestUUIDs.TEST_UUIDS[6]).getParentEntity()); |
| |
| } |
| |
| @Test |
| public void testGetParentEntity() throws Exception { |
| XStreamPersistenceComponent p = new XStreamPersistenceComponent(); |
| p.registerEntityClass(TestEntityBase.class); |
| |
| // insert all the entities and calculate the relations |
| updateCache(p, parent1, parent2, entity1, entity2, entity3, entity4, entity5, entity6, entity7); |
| p.resolveEntityRelations(TestEntityBase.class); |
| |
| TestEntityBase.assertEquals(parent1, entity1.getParentEntity()); |
| TestEntityBase.assertEquals(entity1, entity2.getParentEntity()); |
| Assert.assertNull(entity3.getParentEntity()); |
| TestEntityBase.assertEquals(parent2, entity4.getParentEntity()); |
| TestEntityBase.assertEquals(parent1, entity5.getParentEntity()); |
| TestEntityBase.assertEquals(parent1, entity6.getParentEntity()); |
| TestEntityBase.assertEquals(parent1, entity7.getParentEntity()); |
| |
| assertParentEntity(p, null, parent1); |
| assertParentEntity(p, null, parent2); |
| assertParentEntity(p, parent1, entity1); |
| assertParentEntity(p, entity1, entity2); |
| assertParentEntity(p, null, entity3); |
| assertParentEntity(p, parent2, entity4); |
| assertParentEntity(p, parent1, entity5); |
| assertParentEntity(p, parent1, entity6); |
| assertParentEntity(p, parent1, entity7); |
| } |
| |
| @Test |
| public void testResolveSingleEntityRelations() throws Exception { |
| XStreamPersistenceComponent p = new XStreamPersistenceComponent(); |
| p.registerEntityClass(TestEntityBase.class); |
| |
| updateCache(p, parent1, parent2, entity1, entity2, entity3, entity4, entity5, entity6, entity7); |
| resolveRelations(p, parent1, parent2, entity1, entity2, entity3, entity4, entity5, entity6, entity7); |
| |
| assertSiblingChain(parent1, entity1, entity6, entity7); |
| assertSiblingChain(parent2, entity4); |
| assertSiblingChain(entity1, entity2); |
| assertSiblingChain(entity2, (EntityBase[])null); |
| assertSiblingChain(entity3, (EntityBase[])null); |
| assertSiblingChain(entity4, (EntityBase[])null); |
| assertSiblingChain(entity5, (EntityBase[])null); |
| assertSiblingChain(entity6, (EntityBase[])null); |
| assertSiblingChain(entity7, (EntityBase[])null); |
| } |
| |
| @Test |
| public void testAdjustEntityRelations() throws Exception { |
| XStreamPersistenceComponent p = new XStreamPersistenceComponent(); |
| p.registerEntityClass(TestEntityBase.class); |
| |
| TestEntityBase parent3 = new TestEntityBase(TestUUIDs.TEST_UUIDS[10]); |
| updateCache(p, parent1, parent2, parent3, entity1, entity4); |
| resolveRelations(p, parent1, parent2, parent3, entity1, entity4); |
| assertSiblingChain(parent1, entity1); |
| assertSiblingChain(parent2, entity4); |
| assertSiblingChain(parent3, (EntityBase[])null); |
| |
| // adding new children not previously in the child list |
| p.adjustEntityRelations(TestEntityBase.class, null, entity6); |
| assertSiblingChain(parent1, entity1, entity6); |
| p.adjustEntityRelations(TestEntityBase.class, null, entity7); |
| assertSiblingChain(parent1, entity1, entity6, entity7); |
| |
| // replacing an unchanged entity with itself does nothing |
| p.adjustEntityRelations(TestEntityBase.class, entity1, entity1); |
| assertSiblingChain(parent1, entity1, entity6, entity7); |
| p.adjustEntityRelations(TestEntityBase.class, entity6, entity6); |
| assertSiblingChain(parent1, entity1, entity6, entity7); |
| p.adjustEntityRelations(TestEntityBase.class, entity7, entity7); |
| assertSiblingChain(parent1, entity1, entity6, entity7); |
| p.adjustEntityRelations(TestEntityBase.class, entity4, entity4); |
| assertSiblingChain(parent2, entity4); |
| |
| // adding a deleted child to a non-deleted parent does not change |
| // the child list of that parent, but the deleted child gets a parent |
| p.adjustEntityRelations(TestEntityBase.class, null, entity5); |
| assertSiblingChain(parent1, entity1, entity6, entity7); |
| TestEntityBase.assertEquals(parent1, entity5.getParentEntity()); |
| |
| // changing the content of an entity just replaces the instance in the child list |
| TestEntityBase entity8 = new TestEntityBase(TestUUIDs.TEST_UUIDS[2], TestUUIDs.TEST_UUIDS[0]); |
| entity8.setStr("foobar"); |
| p.adjustEntityRelations(TestEntityBase.class, entity1, entity8); |
| assertSiblingChain(parent1, entity8, entity6, entity7); |
| TestEntityBase.assertEquals(parent1, entity1.getParentEntity()); |
| TestEntityBase.assertEquals(parent1, entity8.getParentEntity()); |
| |
| // removing the parent pointer from an entity removes it from the child list of that parent |
| TestEntityBase entity9 = new TestEntityBase(TestUUIDs.TEST_UUIDS[2], null); |
| p.adjustEntityRelations(TestEntityBase.class, entity8, entity9); |
| assertSiblingChain(parent1, entity6, entity7); |
| TestEntityBase.assertEquals(parent1, entity8.getParentEntity()); |
| Assert.assertNull(entity9.getParentEntity()); |
| |
| // setting the parent pointer of an entity adds it to the child list of that parent |
| p.adjustEntityRelations(TestEntityBase.class, entity9, entity8); |
| assertSiblingChain(parent1, entity6, entity7, entity8); |
| TestEntityBase.assertEquals(parent1, entity8.getParentEntity()); |
| Assert.assertNull(entity9.getParentEntity()); |
| |
| // setting the deleted flag on an entity removes that entity from the child list |
| // of its parent but does not change its parent pointer: a deleted entity can have a |
| // non-deleted parent |
| TestEntityBase entity10 = new TestEntityBase(TestUUIDs.TEST_UUIDS[7], TestUUIDs.TEST_UUIDS[0]); |
| entity10.setDeleted(true); |
| p.adjustEntityRelations(TestEntityBase.class, entity6, entity10); |
| assertSiblingChain(parent1, entity7, entity8); |
| TestEntityBase.assertEquals(parent1, entity6.getParentEntity()); |
| TestEntityBase.assertEquals(parent1, entity10.getParentEntity()); |
| |
| // clearing the deleted flag of a deleted entity with a pointer to a non-deleted parent |
| // adds that entity to the child list of that parent |
| TestEntityBase entity11 = new TestEntityBase(TestUUIDs.TEST_UUIDS[7], TestUUIDs.TEST_UUIDS[0]); |
| p.adjustEntityRelations(TestEntityBase.class, entity10, entity11); |
| assertSiblingChain(parent1, entity7, entity8, entity11); |
| TestEntityBase.assertEquals(parent1, entity10.getParentEntity()); |
| TestEntityBase.assertEquals(parent1, entity11.getParentEntity()); |
| |
| // adding another deleted entity to a deleted parent |
| TestEntityBase entity12 = new TestEntityBase(TestUUIDs.TEST_UUIDS[9], TestUUIDs.TEST_UUIDS[1]); |
| entity12.setDeleted(true); |
| p.adjustEntityRelations(TestEntityBase.class, null, entity12); |
| assertSiblingChain(parent2, entity4, entity12); |
| TestEntityBase.assertEquals(parent2, entity12.getParentEntity()); |
| |
| // clearing the deleted flag of a deleted entity removes that entity from the child list of its parent |
| // and sets its parent pointer to null: a non-deleted entity must not have a deleted parent! |
| TestEntityBase entity13 = new TestEntityBase(TestUUIDs.TEST_UUIDS[5], TestUUIDs.TEST_UUIDS[1]); |
| p.adjustEntityRelations(TestEntityBase.class, entity4, entity13); |
| assertSiblingChain(parent2, entity12); |
| TestEntityBase.assertEquals(parent2, entity4.getParentEntity()); |
| Assert.assertNull(entity13.getParentEntity()); |
| |
| // setting the deleted flag of an entity with a pointer to a deleted parent |
| // adds the entity to the child list of that parent |
| TestEntityBase entity14 = new TestEntityBase(TestUUIDs.TEST_UUIDS[5], TestUUIDs.TEST_UUIDS[1]); |
| entity14.setDeleted(true); |
| p.adjustEntityRelations(TestEntityBase.class, entity13, entity14); |
| assertSiblingChain(parent2, entity12, entity14); |
| TestEntityBase.assertEquals(parent2, entity14.getParentEntity()); |
| |
| // changing the parent of an entity removes the entity from the children of the old parent |
| // and adds it to the children of the new parent |
| TestEntityBase entity15 = new TestEntityBase(TestUUIDs.TEST_UUIDS[8], TestUUIDs.TEST_UUIDS[10]); |
| p.adjustEntityRelations(TestEntityBase.class, entity7, entity15); |
| assertSiblingChain(parent1, entity8, entity11); |
| assertSiblingChain(parent3, entity15); |
| TestEntityBase.assertEquals(parent1, entity8.getParentEntity()); |
| TestEntityBase.assertEquals(parent3, entity15.getParentEntity()); |
| } |
| |
| @Test |
| public void testInsertChildEntity() throws Exception { |
| XStreamPersistenceComponent p = new XStreamPersistenceComponent(); |
| p.registerEntityClass(TestEntityBase.class); |
| |
| // inserting entity1: parent1 has now a child, but entity1 has no siblings yet |
| p.insertChildEntity(parent1, entity1); |
| assertSiblingChain(parent1, entity1); |
| |
| // inserting the unchanged entity1 again has no effect |
| p.insertChildEntity(parent1, entity1); |
| assertSiblingChain(parent1, entity1); |
| |
| // inserting entity6 with string content "foo" |
| entity6.setStr("foo"); |
| p.insertChildEntity(parent1, entity6); |
| assertSiblingChain(parent1, entity1, entity6); |
| |
| // inserting entity7 and again entity1 |
| p.insertChildEntity(parent1, entity7); |
| p.insertChildEntity(parent1, entity1); |
| assertSiblingChain(parent1, entity1, entity6, entity7); |
| |
| // inserting entity6 again, but with a different content "bar" |
| entity6.setStr("bar"); |
| p.insertChildEntity(parent1, entity6); |
| assertSiblingChain(parent1, entity1, entity6, entity7); |
| |
| // inserting entity8, which has the same uuid as entity6 |
| TestEntityBase entity8 = new TestEntityBase(TestUUIDs.TEST_UUIDS[7], TestUUIDs.TEST_UUIDS[0]); |
| entity8.setStr("foobar"); |
| p.insertChildEntity(parent1, entity8); |
| assertSiblingChain(parent1, entity1, entity8, entity7); |
| |
| // inserting entity9, which has the same uuid as entity1 |
| TestEntityBase entity9 = new TestEntityBase(TestUUIDs.TEST_UUIDS[2], TestUUIDs.TEST_UUIDS[0]); |
| entity9.setStr("foobar"); |
| p.insertChildEntity(parent1, entity9); |
| assertSiblingChain(parent1, entity9, entity8, entity7); |
| |
| // inserting entity10, which has the same uuid as entity7 |
| TestEntityBase entity10 = new TestEntityBase(TestUUIDs.TEST_UUIDS[8], TestUUIDs.TEST_UUIDS[0]); |
| entity10.setStr("foobar"); |
| p.insertChildEntity(parent1, entity10); |
| assertSiblingChain(parent1, entity9, entity8, entity10); |
| |
| // adding a deleted entity to a non-deleted parent does nothing |
| TestEntityBase entity11 = new TestEntityBase(TestUUIDs.TEST_UUIDS[3], TestUUIDs.TEST_UUIDS[0]); |
| entity11.setDeleted(true); |
| p.insertChildEntity(parent1, entity11); |
| assertSiblingChain(parent1, entity9, entity8, entity10); |
| |
| // adding a deleted entity to the deleted parent2 works: |
| p.insertChildEntity(parent2, entity11); |
| assertSiblingChain(parent2, entity11); |
| |
| // adding a non-deleted entity to the deleted parent2 does nothing |
| p.insertChildEntity(parent2, entity1); |
| assertSiblingChain(parent2, entity11); |
| } |
| |
| @Test |
| public void testRemoveChildEntity() throws Exception { |
| XStreamPersistenceComponent p = new XStreamPersistenceComponent(); |
| p.registerEntityClass(TestEntityBase.class); |
| |
| // removing an entity that has never been inserted has no effect |
| assertSiblingChain(parent1); |
| p.removeChildEntity(parent1, entity1); |
| assertSiblingChain(parent1); |
| |
| // now inserting entity1: parent1 has a child |
| p.insertChildEntity(parent1, entity1); |
| assertSiblingChain(parent1, entity1); |
| |
| // and removing it again: parent1 has no children |
| p.removeChildEntity(parent1, entity1); |
| assertSiblingChain(parent1); |
| |
| // inserting some entities, then removing entity2 |
| p.insertChildEntity(parent1, entity1); |
| p.insertChildEntity(parent1, entity6); |
| p.insertChildEntity(parent1, entity7); |
| p.removeChildEntity(parent1, entity6); |
| assertSiblingChain(parent1, entity1, entity7); |
| |
| // removing the tail of the siblings chain |
| p.removeChildEntity(parent1, entity7); |
| assertSiblingChain(parent1, entity1); |
| |
| // removing entity3 again has no effect: it was never a child |
| p.removeChildEntity(parent1, entity3); |
| assertSiblingChain(parent1, entity1); |
| |
| // finally removing entity1: parent1 has no children |
| p.removeChildEntity(parent1, entity1); |
| assertSiblingChain(parent1); |
| } |
| |
| private List<TestExtensibleEntityBase> createTestEntityHierarchy() |
| throws Exception { |
| List<TestExtensibleEntityBase> entities = new LinkedList<TestExtensibleEntityBase>(); |
| |
| TestExtensibleEntityBase parentParent = new TestExtensibleEntityBase(TestUUIDs.TEST_UUIDS[2]); |
| entities.add(parentParent); |
| ExtensionEntityBase exts2[] = { createExtension(TestExtension.class, true, "foo", "1", "2"), |
| createExtension(TestExtension1.class, false, "bar", "3") }; |
| addExtensions(parentParent, exts2); |
| |
| TestExtensibleEntityBase parent = new TestExtensibleEntityBase(TestUUIDs.TEST_UUIDS[1]); |
| entities.add(parent); |
| ExtensionEntityBase exts1[] = { createExtension(TestExtension.class, true, "Z", "F", "G", "H", "I"), |
| createExtension(TestExtension1.class, true, "Y", "D", "E") }; |
| addExtensions(parent, exts1); |
| parent.setParentEntity(parentParent); |
| |
| TestExtensibleEntityBase base = new TestExtensibleEntityBase(TestUUIDs.TEST_UUIDS[0]); |
| entities.add(base); |
| ExtensionEntityBase exts0[] = { createExtension(TestExtension.class, false, "X", "A", "B", "C") }; |
| base.setInherited(TestExtension1.class, true); |
| addExtensions(base, exts0); |
| base.setParentEntity(parent); |
| |
| TestExtensibleEntityBase deletedParent = new TestExtensibleEntityBase(TestUUIDs.TEST_UUIDS[4]); |
| deletedParent.setDeleted(true); |
| entities.add(deletedParent); |
| ExtensionEntityBase exts4[] = { createExtension(TestExtension1.class, false, "deleted parent", "d", "e") }; |
| addExtensions(deletedParent, exts4); |
| |
| TestExtensibleEntityBase deleted = new TestExtensibleEntityBase(TestUUIDs.TEST_UUIDS[3]); |
| deleted.setDeleted(true); |
| entities.add(deleted); |
| ExtensionEntityBase exts3[] = { createExtension(TestExtension.class, false, "deleted", "a", "b", "c") }; |
| addExtensions(deleted, exts3); |
| deleted.setParentEntity(deletedParent); |
| |
| return entities; |
| } |
| |
| private void addExtensions(ExtensibleEntityBase base, ExtensionEntityBase... exts) { |
| for (ExtensionEntityBase ext : exts) { |
| base.addExtension(ext); |
| } |
| } |
| |
| private ExtensionEntityBase createExtension(Class<? extends ExtensionEntityBase> clazz, |
| boolean bool, String str, String... items) throws Exception { |
| TestExtension ext = (TestExtension) clazz.newInstance(); |
| ext.setBool(bool); |
| ext.setStr(str); |
| for (String item : items) { |
| ext.addItem(item); |
| } |
| return ext; |
| } |
| |
| private void updateCache(XStreamPersistenceComponent p, EntityBase...entities) { |
| for (EntityBase entity: entities) { |
| p.updateCache(entity); |
| } |
| } |
| |
| private void resolveRelations(XStreamPersistenceComponent p, EntityBase...entities) { |
| for (EntityBase entity: entities) { |
| p.resolveEntityRelations(TestEntityBase.class, entity); |
| } |
| } |
| |
| private void assertParentEntity(XStreamPersistenceComponent p, EntityBase expectedParent, EntityBase entity) { |
| TestEntityBase.assertEquals(expectedParent, p.getParentEntity(TestEntityBase.class, entity)); |
| } |
| |
| private void assertSiblingChain(EntityBase parent, EntityBase...expectedSiblings) { |
| if (expectedSiblings == null || expectedSiblings.length == 0) { |
| Assert.assertNull(parent.getFirstChild()); |
| return; |
| } |
| EntityBase sibling = parent.getFirstChild(); |
| for (EntityBase expectedSibling: expectedSiblings) { |
| Assert.assertNotNull(parent + " misses expected sibling " + expectedSibling, sibling); |
| // assert that the instances are not only equal (which means for |
| // EntityBase equality of the UUIDs), but identical pointers! |
| Assert.assertTrue(expectedSibling == sibling); |
| // assert that all siblings have the given parent |
| Assert.assertTrue(parent == sibling.getParentEntity()); |
| sibling = sibling.getNextSibling(); |
| } |
| Assert.assertNull(parent + " has more siblings than expected", sibling); |
| } |
| |
| private void assertNode(Node node, TestExtensibleEntityBase entity) { |
| String nodeName = node.getNodeName(); |
| if ("uuid".equals(nodeName)) { |
| Assert.assertEquals(entity.getUuid().toString(), node.getTextContent()); |
| } |
| else if ("deleted".equals(nodeName)) { |
| Assert.assertEquals(Boolean.toString(entity.isDeleted()), node.getTextContent()); |
| } |
| else if ("parentEntityId".equals(nodeName)) { |
| Assert.assertEquals(entity.getParentEntityId().toString(), node.getTextContent()); |
| } |
| else if ("extensions".equals(nodeName)) { |
| assertExtensions(node, entity); |
| } |
| else if ("inheritedExtensions".equals(nodeName)) { |
| assertInheritedExtensions(node, entity); |
| } |
| } |
| |
| private void assertExtensions(Node node, TestExtensibleEntityBase entity) { |
| NodeList extNodes = node.getChildNodes(); |
| for (int j = 0; j < extNodes.getLength(); ++j) { |
| Node extNode = extNodes.item(j); |
| String extNodeName = extNode.getNodeName(); |
| if (TestExtension.class.getName().equals(extNodeName)) { |
| assertExtension(extNode, entity.getExtension(TestExtension.class)); |
| } |
| else if (TestExtension1.class.getName().equals(extNodeName)) { |
| assertExtension(extNode, entity.getExtension(TestExtension1.class)); |
| } |
| } |
| } |
| |
| private void assertExtension(Node extNode, TestExtension extension) { |
| Assert.assertNotNull(extension); |
| NodeList nodes = extNode.getChildNodes(); |
| for (int i = 0; i < nodes.getLength(); ++i) { |
| Node node = nodes.item(i); |
| String nodeName = node.getNodeName(); |
| if ("bool".equals(nodeName)) { |
| Assert.assertEquals(Boolean.toString(extension.isBool()), node.getTextContent()); |
| } |
| else if ("str".equals(nodeName)) { |
| Assert.assertEquals(extension.getStr(), node.getTextContent()); |
| } |
| else if ("items".equals(nodeName)) { |
| assertItems(node, extension.getItems()); |
| } |
| } |
| } |
| |
| private void assertItems(Node node, List<String> items) { |
| NodeList itemNodes = node.getChildNodes(); |
| int n = 0; |
| for (int j = 0; j < itemNodes.getLength(); ++j) { |
| Node itemNode = itemNodes.item(j); |
| if ("string".equals(itemNode.getNodeName())) { |
| Assert.assertEquals(items.get(n++), itemNode.getTextContent()); |
| } |
| } |
| } |
| |
| private void assertInheritedExtensions(Node node, TestExtensibleEntityBase entity) { |
| NodeList extNodes = node.getChildNodes(); |
| for (int j = 0; j < extNodes.getLength(); ++j) { |
| Node extNode = extNodes.item(j); |
| String extNodeName = extNode.getNodeName(); |
| if ("string".equals(extNodeName)) { |
| String inheritedEntityName = extNode.getTextContent(); |
| if (TestExtension.class.getName().equals(inheritedEntityName)) { |
| Assert.assertTrue(entity.isInherited(TestExtension.class)); |
| } |
| else if (TestExtension1.class.getName().equals(inheritedEntityName)) { |
| Assert.assertTrue(entity.isInherited(TestExtension1.class)); |
| } |
| } |
| } |
| } |
| } |
