Method: testPersistWithGeneratedIntoContext()

1: /**
2: * Copyright (C) 2016 Czech Technical University in Prague
3: * <p>
4: * This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public
5: * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later
6: * version.
7: * <p>
8: * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
9: * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
10: * details. You should have received a copy of the GNU General Public License along with this program. If not, see
11: * <http://www.gnu.org/licenses/>.
12: */
13: package cz.cvut.kbss.jopa.test.runner;
14:
15: import cz.cvut.kbss.jopa.exceptions.OWLEntityExistsException;
16: import cz.cvut.kbss.jopa.model.descriptors.Descriptor;
17: import cz.cvut.kbss.jopa.model.descriptors.EntityDescriptor;
18: import cz.cvut.kbss.jopa.model.descriptors.ObjectPropertyCollectionDescriptor;
19: import cz.cvut.kbss.jopa.test.*;
20: import cz.cvut.kbss.jopa.test.environment.Generators;
21: import org.junit.Test;
22: import org.slf4j.Logger;
23:
24: import java.net.URI;
25: import java.util.Map;
26: import java.util.Set;
27:
28: import static org.junit.Assert.*;
29:
30: public abstract class CreateOperationsMultiContextRunner extends BaseRunner {
31:
32: private OWLClassF entityF;
33: private OWLClassK entityK;
34:
35: public CreateOperationsMultiContextRunner(Logger logger) {
36: super(logger);
37: initialize();
38: }
39:
40: private void initialize() {
41: this.entityF = new OWLClassF();
42: entityF.setUri(URI.create("http://krizik.felk.cvut.cz/ontologies/jopa/tests/entityF"));
43: this.entityK = new OWLClassK();
44: entityK.setUri(URI.create("http://krizik.felk.cvut.cz/ontologies/jopa/tests/entityK"));
45: }
46:
47: @Test
48: public void testPersistDataPropertyIntoContext() throws Exception {
49: logger.debug("Test: persist an entity into the default context and its data property into a different one.");
50: this.em = getEntityManager("MultiPersistDataPropertyIntoContext", false);
51: final Descriptor aDescriptor = new EntityDescriptor();
52: aDescriptor.addAttributeContext(OWLClassA.class.getDeclaredField("stringAttribute"), CONTEXT_ONE);
53: em.getTransaction().begin();
54: em.persist(entityA, aDescriptor);
55: em.getTransaction().commit();
56:
57: final OWLClassA res = em.find(OWLClassA.class, entityA.getUri(), aDescriptor);
58: assertNotNull(res);
59: assertEquals(entityA.getUri(), res.getUri());
60: assertEquals(entityA.getStringAttribute(), res.getStringAttribute());
61: assertEquals(entityA.getTypes().size(), res.getTypes().size());
62: assertTrue(entityA.getTypes().containsAll(res.getTypes()));
63: }
64:
65: @Test
66: public void testPersistObjectPropertyIntoContext() throws Exception {
67: logger.debug(
68: "Test: persist entity into one context and its object property into another, along with its own attributes.");
69: this.em = getEntityManager("MultiPersistObjectPropertyIntoContext", false);
70: final Descriptor dDescriptor = new EntityDescriptor();
71: final Descriptor aDescriptor = new EntityDescriptor(CONTEXT_ONE);
72: dDescriptor.addAttributeDescriptor(OWLClassD.class.getDeclaredField("owlClassA"), aDescriptor);
73: em.getTransaction().begin();
74: em.persist(entityD, dDescriptor);
75: em.persist(entityA, aDescriptor);
76: em.getTransaction().commit();
77:
78: final OWLClassD resD = em.find(OWLClassD.class, entityD.getUri(), dDescriptor);
79: assertNotNull(resD);
80: assertNotNull(resD.getOwlClassA());
81: final OWLClassA resA = em.find(OWLClassA.class, entityA.getUri(), aDescriptor);
82: assertNotNull(resA);
83: assertEquals(resD.getOwlClassA().getUri(), resA.getUri());
84: assertEquals(resD.getOwlClassA().getStringAttribute(), resA.getStringAttribute());
85: assertTrue(resD.getOwlClassA().getTypes().containsAll(resA.getTypes()));
86: }
87:
88: @Test
89: public void testPersistWithGeneratedIntoContext() {
90: logger.debug("Test: persist entity with generated ID into a context.");
91: this.em = getEntityManager("MultiPersistWithGeneratedIntoContext", false);
92: final Descriptor eDescriptor = new EntityDescriptor(CONTEXT_ONE);
93: em.getTransaction().begin();
94: em.persist(entityE, eDescriptor);
95: em.getTransaction().commit();
96:
97: final OWLClassE res = em.find(OWLClassE.class, entityE.getUri(), eDescriptor);
98: assertNotNull(res);
99: assertEquals(entityE.getUri(), res.getUri());
100: assertEquals(entityE.getStringAttribute(), res.getStringAttribute());
101: }
102:
103: @Test(expected = OWLEntityExistsException.class)
104: public void testPersistTwiceIntoOneContext() {
105: this.em = getEntityManager("MultiPersistTwiceIntoOneContext", false);
106: logger.debug("Test: persist an entity twice into the same context.");
107: final Descriptor aDescriptor = new EntityDescriptor(CONTEXT_ONE);
108: em.getTransaction().begin();
109: em.persist(entityA, aDescriptor);
110: em.getTransaction().commit();
111:
112: assertNotNull(em.find(OWLClassA.class, entityA.getUri(), aDescriptor));
113: em.getTransaction().begin();
114: em.persist(entityA, aDescriptor);
115: em.getTransaction().commit();
116: }
117:
118: @Test
119: public void testPersistTwiceIntoDifferentContexts() {
120: this.em = getEntityManager("MultiPersistTwiceIntoDifferentContexts", false);
121: logger.debug("Test: persist an entity into two different contexts.");
122: final Descriptor aDescriptorOne = new EntityDescriptor(CONTEXT_ONE);
123: final Descriptor aDescriptorTwo = new EntityDescriptor(CONTEXT_TWO);
124: em.getTransaction().begin();
125: em.persist(entityA, aDescriptorOne);
126: em.persist(entityA, aDescriptorTwo);
127: em.getTransaction().commit();
128:
129: final OWLClassA resOne = em.find(OWLClassA.class, entityA.getUri(), aDescriptorOne);
130: assertNotNull(resOne);
131: final OWLClassA resTwo = em.find(OWLClassA.class, entityA.getUri(), aDescriptorTwo);
132: assertNotNull(resTwo);
133: assertNotSame(resOne, resTwo);
134: assertEquals(resOne.getUri(), resTwo.getUri());
135: assertEquals(resOne.getStringAttribute(), resTwo.getStringAttribute());
136: }
137:
138: @Test
139: public void testPersistPropertiesIntoDifferentContext() throws Exception {
140: this.em = getEntityManager("MultiPersistPropertiesIntoDifferentContext", false);
141: logger.debug("Test: persist an entity and persist its properties into a different context.");
142: final Descriptor bDescriptor = new EntityDescriptor();
143: entityB.setProperties(Generators.createProperties(10));
144: bDescriptor.addAttributeContext(OWLClassB.class.getDeclaredField("properties"), CONTEXT_ONE);
145: em.getTransaction().begin();
146: em.persist(entityB, bDescriptor);
147: em.getTransaction().commit();
148:
149: final OWLClassB res = em.find(OWLClassB.class, entityB.getUri(), bDescriptor);
150: assertNotNull(res);
151: assertEquals(entityB.getStringAttribute(), res.getStringAttribute());
152: assertEquals(entityB.getProperties().size(), res.getProperties().size());
153: for (Map.Entry<String, Set<String>> e : res.getProperties().entrySet()) {
154: assertTrue(entityB.getProperties().containsKey(e.getKey()));
155: assertEquals(e.getValue(), entityB.getProperties().get(e.getKey()));
156: }
157: }
158:
159: @Test
160: public void testPersistCascadeIntoThreeContexts() throws Exception {
161: this.em = getEntityManager("MultiPersistCascadeIntoThreeContexts", false);
162: logger.debug("Test: persist three entities in cascaded relationship, each into a different context.");
163: final Descriptor gDescriptor = new EntityDescriptor();
164: final Descriptor hDescriptor = new EntityDescriptor(CONTEXT_ONE);
165: final Descriptor aDescriptor = new EntityDescriptor(CONTEXT_TWO);
166: hDescriptor.addAttributeDescriptor(OWLClassH.class.getDeclaredField("owlClassA"), aDescriptor);
167: gDescriptor.addAttributeDescriptor(OWLClassG.class.getDeclaredField("owlClassH"), hDescriptor);
168: em.getTransaction().begin();
169: em.persist(entityG, gDescriptor);
170: assertTrue(em.contains(entityG));
171: assertTrue(em.contains(entityH));
172: assertTrue(em.contains(entityA));
173: em.getTransaction().commit();
174:
175: final OWLClassA resA = em.find(OWLClassA.class, entityA.getUri(), aDescriptor);
176: assertNotNull(resA);
177: final OWLClassH resH = em.find(OWLClassH.class, entityH.getUri(), hDescriptor);
178: assertNotNull(resH);
179: assertSame(resA, resH.getOwlClassA());
180: final OWLClassG resG = em.find(OWLClassG.class, entityG.getUri(), gDescriptor);
181: assertNotNull(resG);
182: assertSame(resH, resG.getOwlClassH());
183: }
184:
185: @Test
186: public void testPersistSetWithAttributeContexts() throws Exception {
187: logger.debug(
188: "Test: persist entity with simple set, the set will be in a different context and attributes of its element in another.");
189: this.em = getEntityManager("MultiPersistSetWithAttributeContexts", false);
190: entityF.setSimpleSet(Generators.createSimpleSet(20));
191: final Descriptor fDescriptor = new EntityDescriptor();
192: final Descriptor setDescriptor = new ObjectPropertyCollectionDescriptor(CONTEXT_ONE,
193: OWLClassF.class.getDeclaredField("simpleSet"));
194: fDescriptor.addAttributeDescriptor(OWLClassF.class.getDeclaredField("simpleSet"), setDescriptor);
195: setDescriptor.addAttributeContext(OWLClassA.class.getDeclaredField("stringAttribute"), CONTEXT_TWO);
196: setDescriptor.addAttributeContext(OWLClassA.class.getDeclaredField("types"), CONTEXT_TWO);
197: em.getTransaction().begin();
198: em.persist(entityF, fDescriptor);
199: for (OWLClassA a : entityF.getSimpleSet()) {
200: em.persist(a, setDescriptor);
201: }
202: em.getTransaction().commit();
203:
204: final OWLClassF resF = em.find(OWLClassF.class, entityF.getUri(), fDescriptor);
205: assertNotNull(resF);
206: assertEquals(entityF.getSimpleSet().size(), resF.getSimpleSet().size());
207: for (OWLClassA a : resF.getSimpleSet()) {
208: final OWLClassA resA = em.find(OWLClassA.class, a.getUri(), setDescriptor);
209: assertNotNull(resA);
210: assertEquals(a.getStringAttribute(), resA.getStringAttribute());
211: assertEquals(a.getTypes(), resA.getTypes());
212: }
213: }
214:
215: @Test
216: public void testPersistEntityWithObjectPropertyWithGeneratedIdentifierAndPutTheReferenceIntoContext()
217: throws Exception {
218: logger.debug("Test: persist entity with reference to an entity with generated identifier. "
219: + "The identifier should be generated automatically before the referenced entity itself is persisted.");
220: this.em = getEntityManager("PersistEntityWithObjectPropertyWithGeneratedIdentifierContexts", true);
221: entityK.setOwlClassE(entityE);
222: assertNull(entityE.getUri());
223: final Descriptor eDescriptor = new EntityDescriptor(CONTEXT_TWO);
224: final Descriptor kDescriptor = new EntityDescriptor(CONTEXT_ONE);
225: kDescriptor.addAttributeDescriptor(OWLClassK.class.getDeclaredField("owlClassE"), eDescriptor);
226: em.getTransaction().begin();
227: em.persist(entityK, kDescriptor);
228: assertNotNull(entityE.getUri());
229: em.persist(entityE, eDescriptor);
230: em.getTransaction().commit();
231:
232: final OWLClassE resE = em.find(OWLClassE.class, entityE.getUri(), eDescriptor);
233: assertNotNull(resE);
234: assertEquals(entityE.getStringAttribute(), resE.getStringAttribute());
235: final OWLClassK resK = em.find(OWLClassK.class, entityK.getUri(), kDescriptor);
236: assertNotNull(resK);
237: assertEquals(resE, resK.getOwlClassE());
238: }
239: }