Method: initialize()

1: /**
2: * Copyright (C) 2020 Czech Technical University in Prague
3: *
4: * This program is free software: you can redistribute it and/or modify it under
5: * the terms of the GNU General Public License as published by the Free Software
6: * Foundation, either version 3 of the License, or (at your option) any
7: * later version.
8: *
9: * This program is distributed in the hope that it will be useful, but WITHOUT
10: * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11: * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
12: * details. You should have received a copy of the GNU General Public License
13: * along with this program. If not, see <http://www.gnu.org/licenses/>.
14: */
15: package cz.cvut.kbss.jopa.test.runner;
16:
17: import cz.cvut.kbss.jopa.exceptions.OWLEntityExistsException;
18: import cz.cvut.kbss.jopa.model.descriptors.Descriptor;
19: import cz.cvut.kbss.jopa.model.descriptors.EntityDescriptor;
20: import cz.cvut.kbss.jopa.model.descriptors.ObjectPropertyCollectionDescriptor;
21: import cz.cvut.kbss.jopa.model.query.TypedQuery;
22: import cz.cvut.kbss.jopa.test.*;
23: import cz.cvut.kbss.jopa.test.environment.DataAccessor;
24: import cz.cvut.kbss.jopa.test.environment.Generators;
25: import cz.cvut.kbss.jopa.test.environment.PersistenceFactory;
26: import cz.cvut.kbss.jopa.test.environment.Quad;
27: import org.junit.jupiter.api.Test;
28: import org.slf4j.Logger;
29:
30: import java.net.URI;
31: import java.util.Collections;
32: import java.util.Map;
33: import java.util.Set;
34:
35: import static org.junit.jupiter.api.Assertions.*;
36:
37: public abstract class CreateOperationsMultiContextRunner extends BaseRunner {
38:
39: private OWLClassF entityF;
40: private OWLClassK entityK;
41:
42: private EntityDescriptor cOneDescriptor = new EntityDescriptor(CONTEXT_ONE);
43: private EntityDescriptor cTwoDescriptor = new EntityDescriptor(CONTEXT_TWO);
44:
45: public CreateOperationsMultiContextRunner(Logger logger, PersistenceFactory persistenceFactory,
46: DataAccessor dataAccessor) {
47: super(logger, persistenceFactory, dataAccessor);
48: initialize();
49: }
50:
51: private void initialize() {
52: this.entityF = new OWLClassF();
53: entityF.setUri(URI.create("http://krizik.felk.cvut.cz/ontologies/jopa/tests/entityF"));
54: this.entityK = new OWLClassK();
55: entityK.setUri(URI.create("http://krizik.felk.cvut.cz/ontologies/jopa/tests/entityK"));
56: }
57:
58: @Test
59: void testPersistDataPropertyIntoContext() throws Exception {
60: this.em = getEntityManager("MultiPersistDataPropertyIntoContext", false);
61: final Descriptor aDescriptor = new EntityDescriptor();
62: aDescriptor.addAttributeContext(OWLClassA.class.getDeclaredField("stringAttribute"), CONTEXT_ONE);
63: transactional(() -> em.persist(entityA, aDescriptor));
64:
65: final OWLClassA res = findRequired(OWLClassA.class, entityA.getUri(), aDescriptor);
66: assertEquals(entityA.getUri(), res.getUri());
67: assertEquals(entityA.getStringAttribute(), res.getStringAttribute());
68: assertEquals(entityA.getTypes().size(), res.getTypes().size());
69: assertTrue(entityA.getTypes().containsAll(res.getTypes()));
70: }
71:
72: @Test
73: void testPersistObjectPropertyIntoContext() throws Exception {
74: this.em = getEntityManager("MultiPersistObjectPropertyIntoContext", false);
75: final Descriptor dDescriptor = new EntityDescriptor(false);
76: dDescriptor.addAttributeDescriptor(OWLClassD.getOwlClassAField(), cOneDescriptor);
77: transactional(() -> {
78: em.persist(entityD, dDescriptor);
79: em.persist(entityA, cOneDescriptor);
80: });
81:
82: final OWLClassD resD = findRequired(OWLClassD.class, entityD.getUri(), dDescriptor);
83: assertNotNull(resD.getOwlClassA());
84: final OWLClassA resA = findRequired(OWLClassA.class, entityA.getUri(), cOneDescriptor);
85: assertEquals(resD.getOwlClassA().getUri(), resA.getUri());
86: assertEquals(resD.getOwlClassA().getStringAttribute(), resA.getStringAttribute());
87: assertTrue(resD.getOwlClassA().getTypes().containsAll(resA.getTypes()));
88: }
89:
90: @Test
91: void persistWithObjectPropertySavesAssertionIntoSubjectContextByDefault() throws Exception {
92: this.em = getEntityManager("persistWithObjectPropertySavesAssertionIntoSubjectContextByDefault", false);
93: cOneDescriptor.addAttributeDescriptor(OWLClassD.getOwlClassAField(), cTwoDescriptor);
94: transactional(() -> {
95: em.persist(entityD, cOneDescriptor);
96: em.persist(entityA, cTwoDescriptor);
97: });
98:
99: final TypedQuery<Boolean> query = em.createNativeQuery("ASK {GRAPH ?g {?d ?hasA ?a .}}", Boolean.class)
100: .setParameter("g", CONTEXT_ONE).setParameter("d", entityD.getUri())
101: .setParameter("hasA", URI.create(Vocabulary.P_HAS_OWL_CLASS_A))
102: .setParameter("a", entityA.getUri());
103: assertTrue(query.getSingleResult());
104: query.setParameter("g", CONTEXT_TWO);
105: assertFalse(query.getSingleResult());
106: }
107:
108: @Test
109: void persistWithPluralObjectPropertySavesAssertionIntoSubjectContextByDefault() throws Exception {
110: this.em = getEntityManager("persistWithObjectPropertySavesAssertionIntoSubjectContextByDefault", false);
111: final ObjectPropertyCollectionDescriptor opDescriptor = new ObjectPropertyCollectionDescriptor(CONTEXT_TWO,
112: OWLClassF.getSimpleSetField());
113: entityF.setSimpleSet(Collections.singleton(entityA));
114: transactional(() -> em.persist(entityA, cTwoDescriptor));
115:
116: cOneDescriptor.addAttributeDescriptor(OWLClassF.getSimpleSetField(), opDescriptor);
117: transactional(() -> em.persist(entityF, cOneDescriptor));
118:
119: final OWLClassF result = findRequired(OWLClassF.class, entityF.getUri());
120: assertEquals(1, result.getSimpleSet().size());
121: assertEquals(entityA.getUri(), result.getSimpleSet().iterator().next().getUri());
122:
123: final TypedQuery<Boolean> query = em.createNativeQuery("ASK {GRAPH ?g {?f ?hasA ?a .}}", Boolean.class)
124: .setParameter("g", CONTEXT_ONE).setParameter("f", entityF.getUri())
125: .setParameter("hasA", URI.create(Vocabulary.P_F_HAS_SIMPLE_SET))
126: .setParameter("a", entityA.getUri());
127: assertTrue(query.getSingleResult());
128: query.setParameter("g", CONTEXT_TWO);
129: assertFalse(query.getSingleResult());
130: }
131:
132: @Test
133: void testPersistWithGeneratedIntoContext() {
134: this.em = getEntityManager("MultiPersistWithGeneratedIntoContext", false);
135: em.getTransaction().begin();
136: em.persist(entityE, cOneDescriptor);
137: em.getTransaction().commit();
138:
139: final OWLClassE res = findRequired(OWLClassE.class, entityE.getUri(), cOneDescriptor);
140: assertEquals(entityE.getUri(), res.getUri());
141: assertEquals(entityE.getStringAttribute(), res.getStringAttribute());
142: }
143:
144: @Test
145: void testPersistReferenceIntoContextAndThenOwnerIntoDefault() {
146: this.em = getEntityManager("ReferenceIntoContextThenOwnerIntoDefault", false);
147: em.getTransaction().begin();
148: em.persist(entityA, cOneDescriptor);
149: em.getTransaction().commit();
150:
151: em.clear();
152: em.getTransaction().begin();
153: entityD.setOwlClassA(entityA);
154: em.persist(entityD);
155: em.getTransaction().commit();
156:
157: final OWLClassD res = findRequired(OWLClassD.class, entityD.getUri());
158: assertNotNull(res.getOwlClassA());
159: }
160:
161: @Test
162: void persistTwiceIntoSameContextIsInvalid() {
163: this.em = getEntityManager("MultiPersistTwiceIntoOneContext", false);
164: em.getTransaction().begin();
165: em.persist(entityA, cOneDescriptor);
166: em.getTransaction().commit();
167:
168: assertThrows(OWLEntityExistsException.class, () -> {
169: em.getTransaction().begin();
170: em.persist(entityA, cOneDescriptor);
171: em.getTransaction().commit();
172: });
173: }
174:
175: @Test
176: void persistTwiceIntoDifferentContextsIsLegal() {
177: this.em = getEntityManager("MultiPersistTwiceIntoDifferentContexts", false);
178: em.getTransaction().begin();
179: em.persist(entityA, cOneDescriptor);
180: em.getTransaction().commit();
181: em.getTransaction().begin();
182: em.persist(entityA, cTwoDescriptor);
183: em.getTransaction().commit();
184:
185: final OWLClassA resOne = findRequired(OWLClassA.class, entityA.getUri(), cOneDescriptor);
186: final OWLClassA resTwo = findRequired(OWLClassA.class, entityA.getUri(), cTwoDescriptor);
187: assertNotSame(resOne, resTwo);
188: assertEquals(resOne.getUri(), resTwo.getUri());
189: assertEquals(resOne.getStringAttribute(), resTwo.getStringAttribute());
190: }
191:
192: @Test
193: void testPersistPropertiesIntoDifferentContext() throws Exception {
194: this.em = getEntityManager("MultiPersistPropertiesIntoDifferentContext", false);
195: final Descriptor bDescriptor = new EntityDescriptor();
196: entityB.setProperties(Generators.createProperties(10));
197: bDescriptor.addAttributeContext(OWLClassB.class.getDeclaredField("properties"), CONTEXT_ONE);
198: em.getTransaction().begin();
199: em.persist(entityB, bDescriptor);
200: em.getTransaction().commit();
201:
202: final OWLClassB res = findRequired(OWLClassB.class, entityB.getUri(), bDescriptor);
203: assertEquals(entityB.getStringAttribute(), res.getStringAttribute());
204: assertEquals(entityB.getProperties().size(), res.getProperties().size());
205: for (Map.Entry<String, Set<String>> e : res.getProperties().entrySet()) {
206: assertTrue(entityB.getProperties().containsKey(e.getKey()));
207: assertEquals(e.getValue(), entityB.getProperties().get(e.getKey()));
208: }
209: }
210:
211: @Test
212: void testPersistCascadeIntoThreeContexts() throws Exception {
213: this.em = getEntityManager("MultiPersistCascadeIntoThreeContexts", false);
214: final Descriptor gDescriptor = new EntityDescriptor(false);
215: final Descriptor hDescriptor = new EntityDescriptor(CONTEXT_ONE, false);
216: hDescriptor.addAttributeDescriptor(OWLClassH.class.getDeclaredField("owlClassA"), cTwoDescriptor);
217: gDescriptor.addAttributeDescriptor(OWLClassG.class.getDeclaredField("owlClassH"), hDescriptor);
218: em.getTransaction().begin();
219: em.persist(entityG, gDescriptor);
220: assertTrue(em.contains(entityG));
221: assertTrue(em.contains(entityH));
222: assertTrue(em.contains(entityA));
223: em.getTransaction().commit();
224:
225: final OWLClassA resA = findRequired(OWLClassA.class, entityA.getUri(), cTwoDescriptor);
226: final OWLClassH resH = findRequired(OWLClassH.class, entityH.getUri(), hDescriptor);
227: assertSame(resA, resH.getOwlClassA());
228: final OWLClassG resG = findRequired(OWLClassG.class, entityG.getUri(), gDescriptor);
229: assertSame(resH, resG.getOwlClassH());
230: }
231:
232: @Test
233: void persistCascadeIntoThreeContextSavesOPAssertionAlwaysIntoSubjectContextWhenConfigured()
234: throws Exception {
235: this.em = getEntityManager(
236: "persistCascadeIntoThreeContextSavesOPAssertionAlwaysIntoSubjectContextWhenConfigured", false);
237: final Descriptor gDescriptor = new EntityDescriptor();
238: cOneDescriptor.addAttributeDescriptor(OWLClassH.class.getDeclaredField("owlClassA"), cTwoDescriptor);
239: gDescriptor.addAttributeDescriptor(OWLClassG.class.getDeclaredField("owlClassH"), cOneDescriptor);
240: em.getTransaction().begin();
241: em.persist(entityG, gDescriptor);
242: assertTrue(em.contains(entityG));
243: assertTrue(em.contains(entityH));
244: assertTrue(em.contains(entityA));
245: em.getTransaction().commit();
246:
247: assertTrue(em.createNativeQuery("ASK { ?s ?p ?o . }", Boolean.class)
248: .setParameter("s", entityG.getUri())
249: .setParameter("p", URI.create(Vocabulary.P_HAS_H))
250: .setParameter("o", entityH.getUri()).getSingleResult());
251: final TypedQuery<Boolean> query = em.createNativeQuery("ASK {GRAPH ?g { ?s ?p ?o . }}", Boolean.class)
252: .setParameter("g", CONTEXT_ONE)
253: .setParameter("s", entityG.getUri())
254: .setParameter("p", URI.create(Vocabulary.P_HAS_H))
255: .setParameter("o", entityH.getUri());
256: assertFalse(query.getSingleResult());
257: query.setParameter("s", entityH.getUri())
258: .setParameter("p", URI.create(Vocabulary.P_HAS_OWL_CLASS_A))
259: .setParameter("o", entityA.getUri());
260: assertTrue(query.getSingleResult());
261: query.setParameter("g", CONTEXT_TWO);
262: assertFalse(query.getSingleResult());
263: }
264:
265: @Test
266: void testPersistSetWithAttributeContexts() throws Exception {
267: this.em = getEntityManager("MultiPersistSetWithAttributeContexts", false);
268: entityF.setSimpleSet(Generators.createSimpleSet(20));
269: final Descriptor fDescriptor = new EntityDescriptor(false);
270: final ObjectPropertyCollectionDescriptor setDescriptor = new ObjectPropertyCollectionDescriptor(CONTEXT_ONE,
271: OWLClassF.class.getDeclaredField("simpleSet"), false);
272: fDescriptor.addAttributeDescriptor(OWLClassF.class.getDeclaredField("simpleSet"), setDescriptor);
273: setDescriptor.addAttributeContext(OWLClassA.class.getDeclaredField("stringAttribute"), CONTEXT_TWO);
274: setDescriptor.addAttributeContext(OWLClassA.class.getDeclaredField("types"), CONTEXT_TWO);
275: em.getTransaction().begin();
276: em.persist(entityF, fDescriptor);
277: for (OWLClassA a : entityF.getSimpleSet()) {
278: em.persist(a, setDescriptor.getElementDescriptor());
279: }
280: em.getTransaction().commit();
281:
282: final OWLClassF resF = findRequired(OWLClassF.class, entityF.getUri(), fDescriptor);
283: assertEquals(entityF.getSimpleSet().size(), resF.getSimpleSet().size());
284: for (OWLClassA a : resF.getSimpleSet()) {
285: final OWLClassA resA = findRequired(OWLClassA.class, a.getUri(), setDescriptor);
286: assertEquals(a.getStringAttribute(), resA.getStringAttribute());
287: assertEquals(a.getTypes(), resA.getTypes());
288: }
289: }
290:
291: @Test
292: void testPersistEntityWithObjectPropertyWithGeneratedIdentifierAndPutTheReferenceIntoContext()
293: throws Exception {
294: this.em = getEntityManager("PersistEntityWithObjectPropertyWithGeneratedIdentifierContexts", true);
295: entityK.setOwlClassE(entityE);
296: assertNull(entityE.getUri());
297: cOneDescriptor.addAttributeDescriptor(OWLClassK.class.getDeclaredField("owlClassE"), cTwoDescriptor);
298: em.getTransaction().begin();
299: em.persist(entityK, cOneDescriptor);
300: em.persist(entityE, cTwoDescriptor);
301: assertNotNull(entityE.getUri());
302: em.getTransaction().commit();
303:
304: final OWLClassE resE = findRequired(OWLClassE.class, entityE.getUri(), cTwoDescriptor);
305: assertEquals(entityE.getStringAttribute(), resE.getStringAttribute());
306: final OWLClassK resK = findRequired(OWLClassK.class, entityK.getUri(), cOneDescriptor);
307: assertEquals(resE, resK.getOwlClassE());
308: }
309:
310: @Test
311: void testPersistEntityWithMappedSuperclassPuttingReferenceIntoDifferentContext() throws Exception {
312: this.em = getEntityManager("PersistEntityWithMappedSuperclassReferenceInContext", true);
313: cOneDescriptor.addAttributeDescriptor(OWLClassQ.getOWlClassAField(), cTwoDescriptor);
314: cOneDescriptor.addAttributeDescriptor(OWLClassQ.getOWlClassAField(), cTwoDescriptor);
315: em.getTransaction().begin();
316: em.persist(entityQ, cOneDescriptor);
317: em.persist(entityA, cTwoDescriptor);
318: em.getTransaction().commit();
319:
320: final OWLClassA resA = findRequired(OWLClassA.class, entityA.getUri(), cTwoDescriptor);
321: final OWLClassQ resQ = findRequired(OWLClassQ.class, entityQ.getUri(), cOneDescriptor);
322: assertEquals(entityQ.getStringAttribute(), resQ.getStringAttribute());
323: assertEquals(entityQ.getParentString(), resQ.getParentString());
324: assertEquals(entityQ.getLabel(), resQ.getLabel());
325: assertNotNull(resQ.getOwlClassA());
326: assertEquals(resA, resQ.getOwlClassA());
327: }
328:
329: @Test
330: void persistReferenceIntoContextBeforeOwnerDoesNotThrowUnpersistedChangeException() throws Exception {
331: this.em =
332: getEntityManager("persistReferenceIntoContextBeforeOwnerDoesNotThrowUnpersistedChangeException", false);
333: cOneDescriptor.addAttributeDescriptor(OWLClassD.getOwlClassAField(), new EntityDescriptor(null));
334: persist(entityA);
335: transactional(() -> em.persist(entityD, cOneDescriptor));
336:
337: final OWLClassD result = findRequired(OWLClassD.class, entityD.getUri(), cOneDescriptor);
338: assertNotNull(result.getOwlClassA());
339: assertEquals(entityA.getStringAttribute(), result.getOwlClassA().getStringAttribute());
340: }
341:
342: /**
343: * Bug #58
344: */
345: @Test
346: void persistEntityIntoContextAndAttributeIntoDefaultWorksCorrectly() {
347: this.em = getEntityManager("persistEntityIntoContextAndAttributeIntoDefaultWorksCorrectly", false);
348: cOneDescriptor.addAttributeContext(OWLClassA.getStringField(), null);
349: transactional(() -> em.persist(entityA, cOneDescriptor));
350:
351: transactional(() -> {
352: try {
353: verifyStatementsPresent(Collections.singleton(
354: new Quad(entityA.getUri(), URI.create(Vocabulary.P_A_STRING_ATTRIBUTE),
355: entityA.getStringAttribute())), em);
356: verifyStatementsNotPresent(Collections.singleton(
357: new Quad(entityA.getUri(), URI.create(Vocabulary.P_A_STRING_ATTRIBUTE),
358: entityA.getStringAttribute(), CONTEXT_ONE)), em);
359: } catch (Exception e) {
360: throw new RuntimeException(e);
361: }
362: });
363: }
364: }