Method: testPersistDataPropertyIntoContext()

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.model.descriptors.Descriptor;
16: import cz.cvut.kbss.jopa.model.descriptors.EntityDescriptor;
17: import cz.cvut.kbss.jopa.model.descriptors.ObjectPropertyCollectionDescriptor;
18: import cz.cvut.kbss.jopa.test.*;
19: import cz.cvut.kbss.jopa.test.environment.Generators;
20: import org.junit.Test;
21: import org.slf4j.Logger;
22:
23: import java.net.URI;
24: import java.util.Map;
25: import java.util.Set;
26:
27: import static org.junit.Assert.*;
28:
29: public abstract class CreateOperationsMultiContextRunner extends BaseRunner {
30:
31: private OWLClassF entityF;
32: private OWLClassK entityK;
33:
34: public CreateOperationsMultiContextRunner(Logger logger) {
35: super(logger);
36: initialize();
37: }
38:
39: private void initialize() {
40: this.entityF = new OWLClassF();
41: entityF.setUri(URI.create("http://krizik.felk.cvut.cz/ontologies/jopa/tests/entityF"));
42: this.entityK = new OWLClassK();
43: entityK.setUri(URI.create("http://krizik.felk.cvut.cz/ontologies/jopa/tests/entityK"));
44: }
45:
46: @Test
47: public void testPersistDataPropertyIntoContext() throws Exception {
48: logger.debug("Test: persist an entity into the default context and its data property into a different one.");
49: this.em = getEntityManager("MultiPersistDataPropertyIntoContext", false);
50: final Descriptor aDescriptor = new EntityDescriptor();
51: aDescriptor.addAttributeContext(OWLClassA.class.getDeclaredField("stringAttribute"), CONTEXT_ONE);
52: em.getTransaction().begin();
53: em.persist(entityA, aDescriptor);
54: em.getTransaction().commit();
55:
56: final OWLClassA res = em.find(OWLClassA.class, entityA.getUri(), aDescriptor);
57: assertNotNull(res);
58: assertEquals(entityA.getUri(), res.getUri());
59: assertEquals(entityA.getStringAttribute(), res.getStringAttribute());
60: assertEquals(entityA.getTypes().size(), res.getTypes().size());
61: assertTrue(entityA.getTypes().containsAll(res.getTypes()));
62: }
63:
64: @Test
65: public void testPersistObjectPropertyIntoContext() throws Exception {
66: logger.debug(
67: "Test: persist entity into one context and its object property into another, along with its own attributes.");
68: this.em = getEntityManager("MultiPersistObjectPropertyIntoContext", false);
69: final Descriptor dDescriptor = new EntityDescriptor();
70: final Descriptor aDescriptor = new EntityDescriptor(CONTEXT_ONE);
71: dDescriptor.addAttributeDescriptor(OWLClassD.class.getDeclaredField("owlClassA"), aDescriptor);
72: em.getTransaction().begin();
73: em.persist(entityD, dDescriptor);
74: em.persist(entityA, aDescriptor);
75: em.getTransaction().commit();
76:
77: final OWLClassD resD = em.find(OWLClassD.class, entityD.getUri(), dDescriptor);
78: assertNotNull(resD);
79: assertNotNull(resD.getOwlClassA());
80: final OWLClassA resA = em.find(OWLClassA.class, entityA.getUri(), aDescriptor);
81: assertNotNull(resA);
82: assertEquals(resD.getOwlClassA().getUri(), resA.getUri());
83: assertEquals(resD.getOwlClassA().getStringAttribute(), resA.getStringAttribute());
84: assertTrue(resD.getOwlClassA().getTypes().containsAll(resA.getTypes()));
85: }
86:
87: @Test
88: public void testPersistWithGeneratedIntoContext() {
89: logger.debug("Test: persist entity with generated ID into a context.");
90: this.em = getEntityManager("MultiPersistWithGeneratedIntoContext", false);
91: final Descriptor eDescriptor = new EntityDescriptor(CONTEXT_ONE);
92: em.getTransaction().begin();
93: em.persist(entityE, eDescriptor);
94: em.getTransaction().commit();
95:
96: final OWLClassE res = em.find(OWLClassE.class, entityE.getUri(), eDescriptor);
97: assertNotNull(res);
98: assertEquals(entityE.getUri(), res.getUri());
99: assertEquals(entityE.getStringAttribute(), res.getStringAttribute());
100: }
101:
102: @Test
103: public void testPersistReferenceIntoContextAndThenOwnerIntoDefault() {
104: this.em = getEntityManager("ReferenceIntoContextThenOwnerIntoDefault", false);
105: final Descriptor eDescriptor = new EntityDescriptor(CONTEXT_ONE);
106: em.getTransaction().begin();
107: em.persist(entityA, eDescriptor);
108: em.getTransaction().commit();
109:
110: em.clear();
111: em.getTransaction().begin();
112: entityD.setOwlClassA(entityA);
113: em.persist(entityD);
114: em.getTransaction().commit();
115:
116: final OWLClassD res = em.find(OWLClassD.class, entityD.getUri());
117: assertNotNull(res);
118: assertNotNull(res.getOwlClassA());
119: }
120:
121: @Test
122: public void persistTwiceIntoSameContextIsLegal() {
123: this.em = getEntityManager("MultiPersistTwiceIntoOneContext", false);
124: logger.debug("Test: persist an entity twice into the same context.");
125: final Descriptor aDescriptor = new EntityDescriptor(CONTEXT_ONE);
126: em.getTransaction().begin();
127: em.persist(entityA, aDescriptor);
128: em.getTransaction().commit();
129:
130: em.getTransaction().begin();
131: em.persist(entityA, aDescriptor);
132: em.getTransaction().commit();
133: assertNotNull(em.find(OWLClassA.class, entityA.getUri(), aDescriptor));
134: }
135:
136: @Test
137: public void persistTwiceIntoDifferentContextsIsLegal() {
138: this.em = getEntityManager("MultiPersistTwiceIntoDifferentContexts", false);
139: logger.debug("Test: persist an entity into two different contexts.");
140: final Descriptor aDescriptorOne = new EntityDescriptor(CONTEXT_ONE);
141: final Descriptor aDescriptorTwo = new EntityDescriptor(CONTEXT_TWO);
142: em.getTransaction().begin();
143: em.persist(entityA, aDescriptorOne);
144: em.persist(entityA, aDescriptorTwo);
145: em.getTransaction().commit();
146:
147: final OWLClassA resOne = em.find(OWLClassA.class, entityA.getUri(), aDescriptorOne);
148: assertNotNull(resOne);
149: final OWLClassA resTwo = em.find(OWLClassA.class, entityA.getUri(), aDescriptorTwo);
150: assertNotNull(resTwo);
151: assertNotSame(resOne, resTwo);
152: assertEquals(resOne.getUri(), resTwo.getUri());
153: assertEquals(resOne.getStringAttribute(), resTwo.getStringAttribute());
154: }
155:
156: @Test
157: public void testPersistPropertiesIntoDifferentContext() throws Exception {
158: this.em = getEntityManager("MultiPersistPropertiesIntoDifferentContext", false);
159: logger.debug("Test: persist an entity and persist its properties into a different context.");
160: final Descriptor bDescriptor = new EntityDescriptor();
161: entityB.setProperties(Generators.createProperties(10));
162: bDescriptor.addAttributeContext(OWLClassB.class.getDeclaredField("properties"), CONTEXT_ONE);
163: em.getTransaction().begin();
164: em.persist(entityB, bDescriptor);
165: em.getTransaction().commit();
166:
167: final OWLClassB res = em.find(OWLClassB.class, entityB.getUri(), bDescriptor);
168: assertNotNull(res);
169: assertEquals(entityB.getStringAttribute(), res.getStringAttribute());
170: assertEquals(entityB.getProperties().size(), res.getProperties().size());
171: for (Map.Entry<String, Set<String>> e : res.getProperties().entrySet()) {
172: assertTrue(entityB.getProperties().containsKey(e.getKey()));
173: assertEquals(e.getValue(), entityB.getProperties().get(e.getKey()));
174: }
175: }
176:
177: @Test
178: public void testPersistCascadeIntoThreeContexts() throws Exception {
179: this.em = getEntityManager("MultiPersistCascadeIntoThreeContexts", false);
180: logger.debug("Test: persist three entities in cascaded relationship, each into a different context.");
181: final Descriptor gDescriptor = new EntityDescriptor();
182: final Descriptor hDescriptor = new EntityDescriptor(CONTEXT_ONE);
183: final Descriptor aDescriptor = new EntityDescriptor(CONTEXT_TWO);
184: hDescriptor.addAttributeDescriptor(OWLClassH.class.getDeclaredField("owlClassA"), aDescriptor);
185: gDescriptor.addAttributeDescriptor(OWLClassG.class.getDeclaredField("owlClassH"), hDescriptor);
186: em.getTransaction().begin();
187: em.persist(entityG, gDescriptor);
188: assertTrue(em.contains(entityG));
189: assertTrue(em.contains(entityH));
190: assertTrue(em.contains(entityA));
191: em.getTransaction().commit();
192:
193: final OWLClassA resA = em.find(OWLClassA.class, entityA.getUri(), aDescriptor);
194: assertNotNull(resA);
195: final OWLClassH resH = em.find(OWLClassH.class, entityH.getUri(), hDescriptor);
196: assertNotNull(resH);
197: assertSame(resA, resH.getOwlClassA());
198: final OWLClassG resG = em.find(OWLClassG.class, entityG.getUri(), gDescriptor);
199: assertNotNull(resG);
200: assertSame(resH, resG.getOwlClassH());
201: }
202:
203: @Test
204: public void testPersistSetWithAttributeContexts() throws Exception {
205: logger.debug(
206: "Test: persist entity with simple set, the set will be in a different context and attributes of its element in another.");
207: this.em = getEntityManager("MultiPersistSetWithAttributeContexts", false);
208: entityF.setSimpleSet(Generators.createSimpleSet(20));
209: final Descriptor fDescriptor = new EntityDescriptor();
210: final Descriptor setDescriptor = new ObjectPropertyCollectionDescriptor(CONTEXT_ONE,
211: OWLClassF.class.getDeclaredField("simpleSet"));
212: fDescriptor.addAttributeDescriptor(OWLClassF.class.getDeclaredField("simpleSet"), setDescriptor);
213: setDescriptor.addAttributeContext(OWLClassA.class.getDeclaredField("stringAttribute"), CONTEXT_TWO);
214: setDescriptor.addAttributeContext(OWLClassA.class.getDeclaredField("types"), CONTEXT_TWO);
215: em.getTransaction().begin();
216: em.persist(entityF, fDescriptor);
217: for (OWLClassA a : entityF.getSimpleSet()) {
218: em.persist(a, setDescriptor);
219: }
220: em.getTransaction().commit();
221:
222: final OWLClassF resF = em.find(OWLClassF.class, entityF.getUri(), fDescriptor);
223: assertNotNull(resF);
224: assertEquals(entityF.getSimpleSet().size(), resF.getSimpleSet().size());
225: for (OWLClassA a : resF.getSimpleSet()) {
226: final OWLClassA resA = em.find(OWLClassA.class, a.getUri(), setDescriptor);
227: assertNotNull(resA);
228: assertEquals(a.getStringAttribute(), resA.getStringAttribute());
229: assertEquals(a.getTypes(), resA.getTypes());
230: }
231: }
232:
233: @Test
234: public void testPersistEntityWithObjectPropertyWithGeneratedIdentifierAndPutTheReferenceIntoContext()
235: throws Exception {
236: logger.debug("Test: persist entity with reference to an entity with generated identifier. "
237: + "The identifier should be generated automatically before the referenced entity itself is persisted.");
238: this.em = getEntityManager("PersistEntityWithObjectPropertyWithGeneratedIdentifierContexts", true);
239: entityK.setOwlClassE(entityE);
240: assertNull(entityE.getUri());
241: final Descriptor eDescriptor = new EntityDescriptor(CONTEXT_TWO);
242: final Descriptor kDescriptor = new EntityDescriptor(CONTEXT_ONE);
243: kDescriptor.addAttributeDescriptor(OWLClassK.class.getDeclaredField("owlClassE"), eDescriptor);
244: em.getTransaction().begin();
245: em.persist(entityK, kDescriptor);
246: assertNotNull(entityE.getUri());
247: em.persist(entityE, eDescriptor);
248: em.getTransaction().commit();
249:
250: final OWLClassE resE = em.find(OWLClassE.class, entityE.getUri(), eDescriptor);
251: assertNotNull(resE);
252: assertEquals(entityE.getStringAttribute(), resE.getStringAttribute());
253: final OWLClassK resK = em.find(OWLClassK.class, entityK.getUri(), kDescriptor);
254: assertNotNull(resK);
255: assertEquals(resE, resK.getOwlClassE());
256: }
257:
258: @Test
259: public void testPersistEntityWithMappedSuperclassPuttingReferenceIntoDifferentContext() throws Exception {
260: this.em = getEntityManager("PersistEntityWithMappedSuperclassReferenceInContext", true);
261: final Descriptor qDescriptor = new EntityDescriptor(CONTEXT_ONE);
262: final Descriptor aDescriptor = new EntityDescriptor(CONTEXT_TWO);
263: qDescriptor.addAttributeDescriptor(OWLClassQ.getOWlClassAField(), aDescriptor);
264: qDescriptor.addAttributeDescriptor(OWLClassQ.getOWlClassAField(), aDescriptor);
265: em.getTransaction().begin();
266: em.persist(entityQ, qDescriptor);
267: em.persist(entityA, aDescriptor);
268: em.getTransaction().commit();
269:
270: final OWLClassA resA = em.find(OWLClassA.class, entityA.getUri(), aDescriptor);
271: assertNotNull(resA);
272: final OWLClassQ resQ = em.find(OWLClassQ.class, entityQ.getUri(), qDescriptor);
273: assertNotNull(resQ);
274: assertEquals(entityQ.getStringAttribute(), resQ.getStringAttribute());
275: assertEquals(entityQ.getParentString(), resQ.getParentString());
276: assertEquals(entityQ.getLabel(), resQ.getLabel());
277: assertNotNull(resQ.getOwlClassA());
278: assertEquals(resA, resQ.getOwlClassA());
279: }
280: }