Method: modificationsOfCollectionAfterCascadeMergeAreWrittenOnCommit()

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.InferredAttributeModifiedException;
18: import cz.cvut.kbss.jopa.exceptions.IntegrityConstraintViolatedException;
19: import cz.cvut.kbss.jopa.exceptions.RollbackException;
20: import cz.cvut.kbss.jopa.model.descriptors.Descriptor;
21: import cz.cvut.kbss.jopa.model.descriptors.EntityDescriptor;
22: import cz.cvut.kbss.jopa.oom.exceptions.UnpersistedChangeException;
23: import cz.cvut.kbss.jopa.test.*;
24: import cz.cvut.kbss.jopa.test.environment.*;
25: import cz.cvut.kbss.jopa.vocabulary.XSD;
26: import org.junit.jupiter.api.Test;
27: import org.slf4j.Logger;
28:
29: import java.lang.reflect.Field;
30: import java.net.MalformedURLException;
31: import java.net.URI;
32: import java.net.URL;
33: import java.time.Instant;
34: import java.util.*;
35: import java.util.stream.Collectors;
36: import java.util.stream.IntStream;
37:
38: import static org.hamcrest.CoreMatchers.containsString;
39: import static org.hamcrest.CoreMatchers.instanceOf;
40: import static org.hamcrest.MatcherAssert.assertThat;
41: import static org.junit.jupiter.api.Assertions.*;
42:
43: public abstract class UpdateOperationsRunner extends BaseRunner {
44:
45: private OWLClassA entityA2;
46: private OWLClassF entityF;
47: private OWLClassJ entityJ;
48: private OWLClassO entityO;
49:
50: public UpdateOperationsRunner(Logger logger, PersistenceFactory persistenceFactory, DataAccessor dataAccessor) {
51: super(logger, persistenceFactory, dataAccessor);
52: initialize();
53: }
54:
55: private void initialize() {
56: this.entityF = new OWLClassF();
57: entityF.setUri(URI.create("http://krizik.felk.cvut.cz/ontologies/jopa/tests/entityF"));
58: this.entityA2 = new OWLClassA();
59: entityA2.setUri(URI.create("http://krizik.felk.cvut.cz/ontologies/jopa/tests/entityA2"));
60: this.entityJ = new OWLClassJ();
61: entityJ.setUri(URI.create("http://krizik.felk.cvut.cz/ontologies/jopa/tests/entityJ"));
62: final Set<OWLClassA> set = new HashSet<>(2);
63: set.add(entityA);
64: set.add(entityA2);
65: entityJ.setOwlClassA(set);
66: this.entityO = new OWLClassO(URI.create("http://krizik.felk.cvut.cz/ontologies/jopa/tests/entityO"));
67: final Set<OWLClassE> es = new HashSet<>();
68: for (int i = 0; i < 5; i++) {
69: final OWLClassE e = new OWLClassE();
70: e.setStringAttribute("StringAttributeNo" + i);
71: es.add(e);
72: }
73: entityO.setOwlClassESet(es);
74: }
75:
76: @Test
77: void testUpdateDataLeaveLazy() throws Exception {
78: this.em = getEntityManager("UpdateDataProperty", false);
79: entityB.setProperties(Generators.createProperties());
80: persist(entityB);
81:
82: em.getTransaction().begin();
83: final OWLClassB b = findRequired(OWLClassB.class, entityB.getUri());
84: final Field propsField = OWLClassB.class.getDeclaredField("properties");
85: propsField.setAccessible(true);
86: assertNull(propsField.get(b));
87: final String newString = "NewString";
88: b.setStringAttribute(newString);
89: em.getTransaction().commit();
90:
91: final OWLClassB res = findRequired(OWLClassB.class, entityB.getUri());
92: assertEquals(newString, res.getStringAttribute());
93: assertNotNull(res.getProperties());
94: assertEquals(entityB.getProperties(), res.getProperties());
95: }
96:
97: @Test
98: void testUpdateDataPropertySetNull() {
99: this.em = getEntityManager("UpdateDataPropertyToNull", true);
100: persist(entityA);
101:
102: em.getTransaction().begin();
103: final OWLClassA a = findRequired(OWLClassA.class, entityA.getUri());
104: assertNotNull(a.getStringAttribute());
105: a.setStringAttribute(null);
106: em.getTransaction().commit();
107:
108: final OWLClassA res = findRequired(OWLClassA.class, entityA.getUri());
109: assertNull(res.getStringAttribute());
110: assertEquals(entityA.getTypes(), res.getTypes());
111: }
112:
113: @Test
114: void testUpdateReference() {
115: this.em = getEntityManager("UpdateReference", true);
116: persist(entityD, entityI);
117: // em.persist(entityA, ctx);
118:
119: final OWLClassA newA = new OWLClassA();
120: newA.setUri(URI.create("http://krizik.felk.cvut.cz/ontologies/jopa/tests/newEntityA"));
121: newA.setStringAttribute("newA");
122: em.getTransaction().begin();
123: final OWLClassD d = findRequired(OWLClassD.class, entityD.getUri());
124: assertNotNull(d.getOwlClassA());
125: d.setOwlClassA(newA);
126: final OWLClassI i = findRequired(OWLClassI.class, entityI.getUri());
127: assertNotNull(i.getOwlClassA());
128: i.setOwlClassA(newA);
129: em.persist(newA);
130: em.getTransaction().commit();
131:
132: final OWLClassA resA1 = findRequired(OWLClassA.class, newA.getUri());
133: final OWLClassD resD = findRequired(OWLClassD.class, d.getUri());
134: assertEquals(resA1.getUri(), resD.getOwlClassA().getUri());
135: //                assertSame(resD.getOwlClassA(), resA1);
136: verifyExists(OWLClassA.class, entityA.getUri());
137: final OWLClassI resI = findRequired(OWLClassI.class, i.getUri());
138: assertEquals(newA.getUri(), resI.getOwlClassA().getUri());
139: verifyExists(OWLClassA.class, entityA.getUri());
140: assertEquals(resA1.getUri(), resI.getOwlClassA().getUri());
141: //                assertEquals(resA1, resI.getOwlClassA());
142: }
143:
144: @Test
145: void mergedInstanceWithChangesInCascadedPluralReferenceAttributeContainsUpdatedValues() {
146: this.em = getEntityManager("MergeSet", false);
147: persist(entityJ);
148: em.clear();
149:
150: entityJ.getOwlClassA().forEach(a -> a.setStringAttribute("NEWVALUE"));
151:
152: em.getTransaction().begin();
153: OWLClassJ merged = em.merge(entityJ);
154:
155: for (final OWLClassA a : merged.getOwlClassA()) {
156: assertEquals(a.getStringAttribute(), "NEWVALUE");
157: }
158: em.getTransaction().commit();
159: }
160:
161: @Test
162: void testMergeDetachedWithChanges() {
163: this.em = getEntityManager("UpdateDetached", true);
164: persist(entityA);
165:
166: final OWLClassA a = findRequired(OWLClassA.class, entityA.getUri());
167: assertTrue(em.contains(a));
168: em.detach(a);
169: assertFalse(em.contains(a));
170: final String newType = "http://krizik.felk.cvut.cz/ontologies/jopa/entities#AddedType";
171: a.getTypes().add(newType);
172: em.getTransaction().begin();
173: final OWLClassA merged = em.merge(a);
174: assertTrue(merged.getTypes().contains(newType));
175: em.getTransaction().commit();
176:
177: final OWLClassA res = findRequired(OWLClassA.class, a.getUri());
178: assertEquals(a.getTypes().size(), res.getTypes().size());
179: assertTrue(res.getTypes().containsAll(a.getTypes()));
180: }
181:
182: @Test
183: void testMergeDetachedCascade() {
184: this.em = getEntityManager("UpdateCascade", true);
185: em.getTransaction().begin();
186: em.persist(entityH);
187: assertTrue(em.contains(entityA));
188: em.getTransaction().commit();
189:
190: em.getTransaction().begin();
191: final OWLClassH h = findRequired(OWLClassH.class, entityH.getUri());
192: assertNotNull(h.getOwlClassA());
193: em.detach(h);
194: assertFalse(em.contains(h));
195: assertFalse(em.contains(h.getOwlClassA()));
196: final String newStr = "newStringAttribute";
197: h.getOwlClassA().setStringAttribute(newStr);
198: final OWLClassH merged = em.merge(h);
199: assertEquals(newStr, merged.getOwlClassA().getStringAttribute());
200: em.getTransaction().commit();
201:
202: final OWLClassA res = findRequired(OWLClassA.class, entityA.getUri());
203: assertEquals(newStr, res.getStringAttribute());
204: }
205:
206: @Test
207: void testMergeDetachedWithObjectPropertyChange() {
208: this.em = getEntityManager("UpdateDetachedWithOPChange", true);
209: persist(entityD, entityA);
210:
211: final OWLClassD d = findRequired(OWLClassD.class, entityD.getUri());
212: em.detach(d);
213: d.setOwlClassA(entityA2);
214: em.getTransaction().begin();
215: em.merge(d);
216: em.persist(entityA2);
217: em.getTransaction().commit();
218:
219: final OWLClassD res = findRequired(OWLClassD.class, entityD.getUri());
220: assertEquals(entityA2.getUri(), res.getOwlClassA().getUri());
221: assertEquals(entityA2.getStringAttribute(), res.getOwlClassA().getStringAttribute());
222: final OWLClassA resA = findRequired(OWLClassA.class, entityA.getUri());
223: assertEquals(entityA.getStringAttribute(), resA.getStringAttribute());
224: assertEquals(entityA.getTypes(), resA.getTypes());
225: }
226:
227: @Test
228: void testRemoveFromSimpleList() {
229: this.em = getEntityManager("UpdateRemoveFromSimpleList", true);
230: entityC.setSimpleList(Generators.createSimpleList());
231: persistCWithLists(entityC);
232:
233: final OWLClassC c = findRequired(OWLClassC.class, entityC.getUri());
234: em.getTransaction().begin();
235: final OWLClassA a = c.getSimpleList().get(1);
236: c.getSimpleList().remove(a);
237: em.getTransaction().commit();
238:
239: final OWLClassA resA = findRequired(OWLClassA.class, a.getUri());
240: final OWLClassC resC = findRequired(OWLClassC.class, c.getUri());
241: assertEquals(c.getSimpleList().size(), resC.getSimpleList().size());
242: assertEquals(entityC.getSimpleList().size() - 1, resC.getSimpleList().size());
243: for (OWLClassA aa : resC.getSimpleList()) {
244: assertNotEquals(resA.getUri(), aa.getUri());
245: }
246: }
247:
248: @Test
249: void testAddToSimpleList() {
250: this.em = getEntityManager("UpdateAddToSimpleList", true);
251: entityC.setSimpleList(Generators.createSimpleList());
252: em.getTransaction().begin();
253: em.persist(entityC);
254: entityC.getSimpleList().forEach(em::persist);
255: em.persist(entityA);
256: em.getTransaction().commit();
257:
258: em.getTransaction().begin();
259: final OWLClassC c = findRequired(OWLClassC.class, entityC.getUri());
260: final OWLClassA a = findRequired(OWLClassA.class, entityA.getUri());
261: assertFalse(c.getSimpleList().contains(a));
262: c.getSimpleList().add(a);
263: em.getTransaction().commit();
264:
265: final OWLClassC resC = findRequired(OWLClassC.class, entityC.getUri());
266: assertEquals(c.getSimpleList().size(), resC.getSimpleList().size());
267: assertEquals(entityC.getSimpleList().size() + 1, resC.getSimpleList().size());
268: final OWLClassA resA = findRequired(OWLClassA.class, entityA.getUri());
269: assertTrue(resC.getSimpleList().contains(resA));
270: }
271:
272: @Test
273: void testClearSimpleList() {
274: this.em = getEntityManager("UpdateClearSimpleList", true);
275: entityC.setSimpleList(Generators.createSimpleList());
276: persistCWithLists(entityC);
277:
278: final OWLClassC c = findRequired(OWLClassC.class, entityC.getUri());
279: assertFalse(c.getSimpleList().isEmpty());
280: em.getTransaction().begin();
281: c.getSimpleList().clear();
282: em.getTransaction().commit();
283:
284: final OWLClassC resC = findRequired(OWLClassC.class, entityC.getUri());
285: assertTrue(resC.getSimpleList() == null || resC.getSimpleList().isEmpty());
286: for (OWLClassA a : entityC.getSimpleList()) {
287: verifyExists(OWLClassA.class, a.getUri());
288: }
289: }
290:
291: @Test
292: void testReplaceSimpleList() {
293: this.em = getEntityManager("UpdateReplaceSimpleList", true);
294: entityC.setSimpleList(Generators.createSimpleList());
295: persistCWithLists(entityC);
296:
297: final OWLClassC c = findRequired(OWLClassC.class, entityC.getUri());
298: final List<OWLClassA> newList = new ArrayList<>(1);
299: newList.add(entityA);
300: em.getTransaction().begin();
301: em.persist(entityA);
302: c.setSimpleList(newList);
303: em.getTransaction().commit();
304:
305: final OWLClassC resC = findRequired(OWLClassC.class, entityC.getUri());
306: assertEquals(newList.size(), resC.getSimpleList().size());
307: boolean found;
308: for (OWLClassA a : newList) {
309: found = false;
310: for (OWLClassA aa : resC.getSimpleList()) {
311: if (a.getUri().equals(aa.getUri())) {
312: found = true;
313: break;
314: }
315: }
316: assertTrue(found);
317: }
318: for (OWLClassA a : entityC.getSimpleList()) {
319: assertNotNull(em.find(OWLClassA.class, a.getUri()));
320: }
321: }
322:
323: @Test
324: void testRemoveFromReferencedList() {
325: this.em = getEntityManager("UpdateRemoveFromReferencedList", true);
326: entityC.setReferencedList(Generators.createReferencedList());
327: persistCWithLists(entityC);
328:
329: final OWLClassC c = findRequired(OWLClassC.class, entityC.getUri());
330: em.getTransaction().begin();
331: final OWLClassA a = c.getReferencedList().get(Generators.randomInt(c.getReferencedList().size()));
332: c.getReferencedList().remove(a);
333: em.getTransaction().commit();
334:
335: final OWLClassA resA = findRequired(OWLClassA.class, a.getUri());
336: final OWLClassC resC = findRequired(OWLClassC.class, c.getUri());
337: assertEquals(c.getReferencedList().size(), resC.getReferencedList().size());
338: assertEquals(entityC.getReferencedList().size() - 1, resC.getReferencedList().size());
339: for (OWLClassA aa : resC.getReferencedList()) {
340: assertNotEquals(resA.getUri(), aa.getUri());
341: }
342: }
343:
344: @Test
345: void testAddToReferencedList() {
346: this.em = getEntityManager("UpdateAddToReferencedList", true);
347: entityC.setReferencedList(Generators.createReferencedList());
348: persistCWithLists(entityC);
349:
350: em.getTransaction().begin();
351: final OWLClassC c = findRequired(OWLClassC.class, entityC.getUri());
352: em.persist(entityA);
353: c.getReferencedList().add(entityA);
354: em.getTransaction().commit();
355:
356: final OWLClassC resC = findRequired(OWLClassC.class, entityC.getUri());
357: assertEquals(c.getReferencedList().size(), resC.getReferencedList().size());
358: assertEquals(entityC.getReferencedList().size() + 1, resC.getReferencedList().size());
359: final OWLClassA resA = findRequired(OWLClassA.class, entityA.getUri());
360: assertTrue(resC.getReferencedList().contains(resA));
361: }
362:
363: @Test
364: void testClearReferencedList() {
365: this.em = getEntityManager("UpdateClearReferencedList", true);
366: entityC.setReferencedList(Generators.createReferencedList());
367: persistCWithLists(entityC);
368:
369: final OWLClassC c = findRequired(OWLClassC.class, entityC.getUri());
370: assertFalse(c.getReferencedList().isEmpty());
371: em.getTransaction().begin();
372: c.setReferencedList(null);
373: em.getTransaction().commit();
374:
375: final OWLClassC resC = findRequired(OWLClassC.class, entityC.getUri());
376: assertNull(resC.getReferencedList());
377: for (OWLClassA a : entityC.getReferencedList()) {
378: verifyExists(OWLClassA.class, a.getUri());
379: }
380: }
381:
382: @Test
383: void testReplaceReferencedList() {
384: this.em = getEntityManager("UpdateReplaceReferencedList", true);
385: entityC.setReferencedList(Generators.createReferencedList());
386: persistCWithLists(entityC);
387:
388: final OWLClassC c = findRequired(OWLClassC.class, entityC.getUri());
389: final List<OWLClassA> newList = new ArrayList<>(1);
390: newList.add(entityA);
391: em.getTransaction().begin();
392: em.persist(entityA);
393: c.setReferencedList(newList);
394: em.getTransaction().commit();
395:
396: final OWLClassC resC = findRequired(OWLClassC.class, entityC.getUri());
397: assertEquals(newList.size(), resC.getReferencedList().size());
398: boolean found;
399: for (OWLClassA a : newList) {
400: found = false;
401: for (OWLClassA aa : resC.getReferencedList()) {
402: if (a.getUri().equals(aa.getUri())) {
403: found = true;
404: break;
405: }
406: }
407: assertTrue(found);
408: }
409: for (OWLClassA a : entityC.getReferencedList()) {
410: verifyExists(OWLClassA.class, a.getUri());
411: }
412: }
413:
414: @Test
415: void testAddNewToProperties() {
416: this.em = getEntityManager("UpdateAddNewToProperties", false);
417: entityB.setProperties(Generators.createProperties());
418: final Map<String, Set<String>> expected = new HashMap<>(entityB.getProperties().size() + 3);
419: expected.putAll(entityB.getProperties());
420: persist(entityB);
421: em.clear();
422:
423: final OWLClassB b = findRequired(OWLClassB.class, entityB.getUri());
424: assertEquals(expected.size(), b.getProperties().size());
425: em.getTransaction().begin();
426: b.getProperties().put("http://krizik.felk.cvut.cz/ontologies/jopa/attributes#propertyFour",
427: Collections.singleton("http://krizik.felk.cvut.cz/ontologies/jopa/Stroustrup"));
428: expected.putAll(b.getProperties());
429: em.getTransaction().commit();
430:
431: final OWLClassB res = findRequired(OWLClassB.class, b.getUri());
432: assertEquals(expected.size(), res.getProperties().size());
433: for (Map.Entry<String, Set<String>> e : expected.entrySet()) {
434: assertTrue(res.getProperties().containsKey(e.getKey()));
435: final Set<String> s = e.getValue();
436: final Set<String> resS = res.getProperties().get(e.getKey());
437: assertEquals(s.size(), resS.size());
438: assertTrue(s.containsAll(resS));
439: }
440: }
441:
442: @Test
443: void testAddPropertyValue() {
444: this.em = getEntityManager("UpdateAddPropertyValue", false);
445: entityB.setProperties(Generators.createProperties());
446: final Map<String, Set<String>> expected = new HashMap<>(entityB.getProperties().size() + 3);
447: final String prop = entityB.getProperties().keySet().iterator().next();
448: expected.putAll(entityB.getProperties());
449: persist(entityB);
450: em.clear();
451:
452: final OWLClassB b = findRequired(OWLClassB.class, entityB.getUri());
453: assertEquals(expected.size(), b.getProperties().size());
454: em.getTransaction().begin();
455: b.getProperties().get(prop).add("http://krizik.felk.cvut.cz/ontologies/jopa/Stroustrup");
456: expected.putAll(b.getProperties());
457: em.getTransaction().commit();
458:
459: final OWLClassB res = findRequired(OWLClassB.class, b.getUri());
460: assertEquals(expected.size(), res.getProperties().size());
461: for (Map.Entry<String, Set<String>> e : expected.entrySet()) {
462: assertTrue(res.getProperties().containsKey(e.getKey()));
463: final Set<String> s = e.getValue();
464: final Set<String> resS = res.getProperties().get(e.getKey());
465: assertEquals(s.size(), resS.size());
466: if (e.getKey().equals(prop)) {
467: assertTrue(s.size() > 1);
468: for (String val : s) {
469: assertTrue(resS.contains(val));
470: }
471: } else {
472: assertTrue(resS.contains(s.iterator().next()));
473: }
474: }
475: }
476:
477: @Test
478: void testAddPropertyValueDetached() {
479: this.em = getEntityManager("UpdateAddPropertyValueDetached", false);
480: entityB.setProperties(Generators.createProperties());
481: final String prop = entityB.getProperties().keySet().iterator().next();
482: final String newPropertyValue = "http://krizik.felk.cvut.cz/ontologies/jopa#newPropertyValue";
483: persist(entityB);
484: em.clear();
485:
486: final OWLClassB b = findRequired(OWLClassB.class, entityB.getUri());
487: b.getProperties().get(prop).add(newPropertyValue);
488: em.detach(b);
489: em.getTransaction().begin();
490: em.merge(b);
491: em.getTransaction().commit();
492:
493: final OWLClassB res = findRequired(OWLClassB.class, entityB.getUri());
494: assertTrue(res.getProperties().get(prop).contains(newPropertyValue));
495: }
496:
497: @Test
498: void testAddNewTypedPropertyWithValues() {
499: this.em = getEntityManager("UpdateAddNewToPropertiesTyped", false);
500: entityP.setProperties(Generators.createTypedProperties());
501: persist(entityP);
502: em.clear();
503:
504: final OWLClassP p = findRequired(OWLClassP.class, entityP.getUri());
505: em.getTransaction().begin();
506: final URI property = URI.create("http://krizik.felk.cvut.cz/ontologies/jopa#newProperty");
507: p.getProperties().put(property, new HashSet<>(Arrays.asList(1, "Two", new Date())));
508: em.getTransaction().commit();
509:
510: em.clear();
511:
512: final OWLClassP res = findRequired(OWLClassP.class, entityP.getUri());
513: assertTrue(res.getProperties().containsKey(property));
514: assertEquals(p.getProperties(), res.getProperties());
515: }
516:
517: @Test
518: void testAddTypedPropertyValue() {
519: this.em = getEntityManager("UpdateAddPropertyValueTyped", false);
520: entityP.setProperties(Generators.createTypedProperties());
521: persist(entityP);
522: em.clear();
523:
524: final OWLClassP p = findRequired(OWLClassP.class, entityP.getUri());
525: em.getTransaction().begin();
526: final URI property = p.getProperties().keySet().iterator().next();
527: final Object value = generateValueForProperty(p, property);
528: p.getProperties().get(property).add(value);
529: em.getTransaction().commit();
530:
531: final OWLClassP res = findRequired(OWLClassP.class, entityP.getUri());
532: assertTrue(res.getProperties().get(property).contains(value));
533: assertEquals(p.getProperties(), res.getProperties());
534: }
535:
536: private Object generateValueForProperty(OWLClassP instance, URI property) {
537: final Set<Object> values = instance.getProperties().get(property);
538: assert values != null && !values.isEmpty();
539: if (values.iterator().next() instanceof URI) {
540: return URI.create("http://krizik.felk.cvut.cz/ontologies/jopa#newPropertyValue");
541: } else {
542: return "StringValue";
543: }
544: }
545:
546: @Test
547: void testModifyInferredAttribute() {
548: this.em = getEntityManager("ModifyInferredAttribute", false);
549: persist(entityF);
550:
551: em.getTransaction().begin();
552: final OWLClassF f = findRequired(OWLClassF.class, entityF.getUri());
553: assertThrows(InferredAttributeModifiedException.class, () -> f.setSecondStringAttribute("otherValue"));
554: }
555:
556: @Test
557: void testModifyAttributesOfBasicTypes() {
558: this.em = getEntityManager("ModifyBasicTypeAttributes", false);
559: persist(entityM);
560:
561: em.getTransaction().begin();
562: final OWLClassM m = findRequired(OWLClassM.class, entityM.getKey());
563: m.setBooleanAttribute(!entityM.getBooleanAttribute());
564: m.setDoubleAttribute(m.getDoubleAttribute() - 100.0);
565: m.setLongAttribute(m.getLongAttribute() + 100L);
566: m.setDateAttribute(new Date(System.currentTimeMillis() + 10000));
567: em.getTransaction().commit();
568:
569: final OWLClassM res = findRequired(OWLClassM.class, entityM.getKey());
570: assertEquals(m.getBooleanAttribute(), res.getBooleanAttribute());
571: assertEquals(m.getLongAttribute(), res.getLongAttribute());
572: assertEquals(m.getDoubleAttribute(), res.getDoubleAttribute());
573: assertEquals(m.getDateAttribute(), res.getDateAttribute());
574: }
575:
576: @Test
577: void testModifyEnumAttribute() {
578: this.em = getEntityManager("ModifyEnumAttribute", false);
579: assertNotNull(entityM.getEnumAttribute());
580: persist(entityM);
581:
582: final OWLClassM.Severity updated = OWLClassM.Severity.LOW;
583: em.getTransaction().begin();
584: final OWLClassM m = findRequired(OWLClassM.class, entityM.getKey());
585: m.setEnumAttribute(updated);
586: em.getTransaction().commit();
587:
588: final OWLClassM res = findRequired(OWLClassM.class, entityM.getKey());
589: assertEquals(updated, res.getEnumAttribute());
590: }
591:
592: @Test
593: void testCascadeOfNewlyPersistedOnMerge() {
594: this.em = getEntityManager("CascadeMergeWithNewlyPersisted", true);
595: em.getTransaction().begin();
596: em.persist(entityO);
597: entityO.getOwlClassESet().forEach(em::persist);
598: em.getTransaction().commit();
599:
600: final OWLClassE newE = new OWLClassE();
601: newE.setStringAttribute("NewlyAddedE");
602: final OWLClassO toUpdate = em.find(OWLClassO.class, entityO.getUri());
603: em.detach(toUpdate);
604:
605: em.getTransaction().begin();
606: toUpdate.getOwlClassESet().add(newE);
607: em.persist(newE);
608: final OWLClassO merged = em.merge(toUpdate);
609: assertTrue(merged.getOwlClassESet().contains(newE));
610: em.getTransaction().commit();
611:
612: verifyExists(OWLClassE.class, newE.getUri());
613: final OWLClassO resO = findRequired(OWLClassO.class, entityO.getUri());
614: assertEquals(entityO.getOwlClassESet().size() + 1, resO.getOwlClassESet().size());
615: }
616:
617: @Test
618: void modificationsOfCollectionAfterCascadeMergeAreWrittenOnCommit() {
619: this.em = getEntityManager("ModifyCollectionAfterCascadeMerge", true);
620: em.getTransaction().begin();
621: em.persist(entityJ);
622: em.getTransaction().commit();
623:
624: final OWLClassA newA = new OWLClassA(URI.create("http://krizik.felk.cvut.cz/ontologies/jopa/tests/newEntityA"));
625: em.getTransaction().begin();
626: final OWLClassJ merged = em.merge(entityJ);
627: merged.getOwlClassA().add(newA);
628: em.persist(newA);
629: em.getTransaction().commit();
630:
631: final OWLClassJ result = findRequired(OWLClassJ.class, entityJ.getUri());
632: assertEquals(merged.getOwlClassA().size(), result.getOwlClassA().size());
633: boolean found = false;
634:• for (OWLClassA a : result.getOwlClassA()) {
635:• if (a.getUri().equals(newA.getUri())) {
636: found = true;
637: break;
638: }
639: }
640: assertTrue(found);
641: }
642:
643: @Test
644: void testAddPropertiesWhenTheyWereNullOriginally() {
645: this.em = getEntityManager("AddPropertiesToNullOriginals", true);
646: em.getTransaction().begin();
647: assertNull(entityB.getProperties());
648: em.persist(entityB);
649: em.getTransaction().commit();
650:
651: final OWLClassB update = findRequired(OWLClassB.class, entityB.getUri());
652: em.detach(update);
653: final Map<String, Set<String>> properties = Generators.createProperties(2);
654: update.setProperties(properties);
655: em.getTransaction().begin();
656: em.merge(update);
657: em.getTransaction().commit();
658:
659: final OWLClassB result = findRequired(OWLClassB.class, entityB.getUri());
660: assertNotNull(result.getProperties());
661: assertEquals(properties, result.getProperties());
662: }
663:
664: @Test
665: void testUpdatePlainLiteralObjectPropertyValueToAnotherIndividual() {
666: this.em = getEntityManager("UpdatePlainLiteralObjectPropertyValue", true);
667: em.getTransaction().begin();
668: entityP.setIndividualUri(URI.create("http://krizik.felk.cvut.cz/ontologies/jopa#oldIndividual"));
669: em.persist(entityP);
670: em.getTransaction().commit();
671:
672: final OWLClassP update = findRequired(OWLClassP.class, entityP.getUri());
673: final URI newValue = URI.create("http://krizik.felk.cvut.cz/ontologies/jopa#newIndividual");
674: em.getTransaction().begin();
675: update.setIndividualUri(newValue);
676: em.getTransaction().commit();
677:
678: final OWLClassP result = findRequired(OWLClassP.class, entityP.getUri());
679: assertEquals(newValue, result.getIndividualUri());
680: }
681:
682: @Test
683: void testUpdatePlainLiteralObjectPropertyValueToNull() {
684: this.em = getEntityManager("UpdatePlainLiteralObjectPropertyValueToNull", true);
685: em.getTransaction().begin();
686: entityP.setIndividualUri(URI.create("http://krizik.felk.cvut.cz/ontologies/jopa#SomeIndividual"));
687: em.persist(entityP);
688: em.getTransaction().commit();
689:
690: final OWLClassP update = findRequired(OWLClassP.class, entityP.getUri());
691: assertNotNull(update.getIndividualUri());
692: em.getTransaction().begin();
693: update.setIndividualUri(null);
694: em.getTransaction().commit();
695:
696: final OWLClassP result = findRequired(OWLClassP.class, entityP.getUri());
697: assertNull(result.getIndividualUri());
698: }
699:
700: @Test
701: void testUpdatePluralPlainLiteralObjectPropertyAttribute() throws MalformedURLException {
702: this.em = getEntityManager("UpdatePluralPlainLiteralObjectPropertyValue", true);
703: entityP.setIndividuals(Generators.createUrls());
704: persist(entityP);
705:
706: final OWLClassP update = findRequired(OWLClassP.class, entityP.getUri());
707: em.getTransaction().begin();
708: final URL added = new URL("http://krizik.felk.cvut.cz/ontologies/jopa#added");
709: final URL removed = entityP.getIndividuals().iterator().next();
710: update.getIndividuals().add(added);
711: update.getIndividuals().remove(removed);
712: em.getTransaction().commit();
713:
714: final OWLClassP res = findRequired(OWLClassP.class, entityP.getUri());
715: assertEquals(update.getIndividuals(), res.getIndividuals());
716: }
717:
718: @Test
719: void testUpdateSimpleListOfIdentifiersByAddingNewItems() {
720: this.em = getEntityManager("UpdateSimpleListOfIdentifiersByAddingItems", true);
721: entityP.setSimpleList(Generators.createListOfIdentifiers());
722: persist(entityP);
723:
724: final OWLClassP update = findRequired(OWLClassP.class, entityP.getUri());
725: em.getTransaction().begin();
726: for (int i = 0; i < Generators.randomPositiveInt(5, 10); i++) {
727: final URI u = URI.create("http://krizik.felk.cvut.cz/ontologies/jopa#Added-" + i);
728: // Insert at random position
729: update.getSimpleList().add(Generators.randomInt(update.getSimpleList().size()), u);
730: }
731: em.getTransaction().commit();
732:
733: final OWLClassP res = findRequired(OWLClassP.class, entityP.getUri());
734: assertEquals(update.getSimpleList(), res.getSimpleList());
735: }
736:
737: @Test
738: void testUpdateReferencedListByRemovingAndAddingItems() {
739: this.em = getEntityManager("UpdateReferencedListByRemovingAndAddingItems", true);
740: entityP.setReferencedList(Generators.createListOfIdentifiers());
741: persist(entityP);
742:
743: final OWLClassP update = findRequired(OWLClassP.class, entityP.getUri());
744: em.getTransaction().begin();
745: for (int i = 0; i < Generators.randomPositiveInt(5, 10); i++) {
746: final URI u = URI.create("http://krizik.felk.cvut.cz/ontologies/jopa#Added-" + i);
747: // We might even overwrite items set in previous iterations, but it does not matter. JOPA should handle it
748: update.getReferencedList().set(Generators.randomInt(update.getReferencedList().size()), u);
749: }
750: em.getTransaction().commit();
751:
752: final OWLClassP res = findRequired(OWLClassP.class, entityP.getUri());
753: assertEquals(update.getReferencedList(), res.getReferencedList());
754: }
755:
756: @Test
757: void testUpdateStringAnnotationPropertyValue() {
758: this.em = getEntityManager("UpdateStringAnnotationPropertyValue", true);
759: entityN.setAnnotationProperty("PropertyValue");
760: persist(entityN);
761:
762: final String newValue = "newValue";
763: final OWLClassN update = findRequired(OWLClassN.class, entityN.getId());
764: assertNotNull(update);
765: em.getTransaction().begin();
766: update.setAnnotationProperty(newValue);
767: em.getTransaction().commit();
768:
769: final OWLClassN res = findRequired(OWLClassN.class, entityN.getId());
770: assertEquals(newValue, res.getAnnotationProperty());
771: }
772:
773: @Test
774: void testUpdateAnnotationPropertyWithUriValueToDifferentValue() {
775: this.em = getEntityManager("UpdateAnnotationPropertyWithUriValueToDifferentValue", true);
776: entityN.setAnnotationUri(URI.create("http://krizik.felk.cvut.cz/ontologies/jopa#value"));
777: persist(entityN);
778:
779: final OWLClassN update = findRequired(OWLClassN.class, entityN.getId());
780: assertNotNull(update);
781: em.getTransaction().begin();
782: final URI newUri = URI.create("http://krizik.felk.cvut.cz/ontologies/jopa#newValue");
783: update.setAnnotationUri(newUri);
784: em.getTransaction().commit();
785:
786: final OWLClassN res = findRequired(OWLClassN.class, entityN.getId());
787: assertEquals(newUri, res.getAnnotationUri());
788: }
789:
790: @Test
791: void testUpdateUriTypes() {
792: this.em = getEntityManager("UpdateUriTypes", true);
793: entityP.setTypes(Generators.createUriTypes());
794: persist(entityP);
795:
796: em.getTransaction().begin();
797: final OWLClassP update = findRequired(OWLClassP.class, entityP.getUri());
798: final Iterator<URI> it = update.getTypes().iterator();
799: while (it.hasNext()) {
800: it.next();
801: if (Generators.randomBoolean()) {
802: it.remove();
803: }
804: }
805: update.getTypes().addAll(Generators.createUriTypes());
806: em.getTransaction().commit();
807:
808: final OWLClassP result = findRequired(OWLClassP.class, entityP.getUri());
809: assertEquals(update.getTypes().size(), result.getTypes().size());
810: assertTrue(update.getTypes().containsAll(result.getTypes()));
811: }
812:
813: @Test
814: void updateWithInvalidInstanceThrowsIntegrityConstraintsViolation() {
815: this.em = getEntityManager("UpdateWithInvalidInstanceThrowsICViolation", true);
816: persist(entityN);
817:
818: entityN.setStringAttribute(null);
819: em.getTransaction().begin();
820: final RollbackException ex = assertThrows(RollbackException.class, () -> {
821: em.merge(entityN);
822: em.getTransaction().commit();
823: });
824: assertThat(ex.getCause(), instanceOf(IntegrityConstraintViolatedException.class));
825: }
826:
827: @Test
828: void addingValuesToDatatypePropertyCollectionAddsThemIntoRepository() {
829: this.em = getEntityManager("addingValuesToDatatypePropertyCollectionAddsThemIntoRepository", false);
830: persist(entityM);
831:
832: IntStream.generate(Generators::randomInt).limit(7).forEach(entityM.getIntegerSet()::add);
833: em.getTransaction().begin();
834: em.merge(entityM);
835: em.getTransaction().commit();
836:
837: final OWLClassM result = findRequired(OWLClassM.class, entityM.getKey());
838: assertEquals(entityM.getIntegerSet(), result.getIntegerSet());
839: }
840:
841: @Test
842: void removingValuesFromDatatypePropertyCollectionRemovesThemFromRepository() {
843: this.em = getEntityManager("removingValuesFromDatatypePropertyCollectionRemovesThemFromRepository", false);
844: persist(entityM);
845:
846: final Iterator<Integer> it = entityM.getIntegerSet().iterator();
847: while (it.hasNext()) {
848: it.next();
849: if (Generators.randomBoolean()) {
850: it.remove();
851: }
852: }
853: // Make sure there is at least one element
854: entityM.getIntegerSet().add(Generators.randomInt());
855:
856: em.getTransaction().begin();
857: em.merge(entityM);
858: em.getTransaction().commit();
859:
860: final OWLClassM result = findRequired(OWLClassM.class, entityM.getKey());
861: assertEquals(entityM.getIntegerSet(), result.getIntegerSet());
862: }
863:
864: @Test
865: void mergeReplacesReferenceWithInstanceFromRepository() {
866: this.em = getEntityManager("mergeReplacesReferenceWithInstanceFromRepository", true);
867: persist(entityD, entityA);
868:
869: final String originalString = entityA.getStringAttribute();
870: entityA.setStringAttribute("updatedStringAttribute");
871: em.getTransaction().begin();
872: final OWLClassD merged = em.merge(entityD);
873: assertEquals(originalString, merged.getOwlClassA().getStringAttribute());
874: em.getTransaction().commit();
875:
876: final OWLClassA result = findRequired(OWLClassA.class, entityA.getUri());
877: assertEquals(originalString, result.getStringAttribute());
878: }
879:
880: @Test
881: void mergeMergesUpdatedDataPropertyFields() {
882: this.em = getEntityManager("mergeMergesUpdatedDataPropertyFields", true);
883: persist(entityA);
884: final Set<String> newTypes =
885: Generators.createUriTypes().stream().map(URI::toString).collect(Collectors.toSet());
886: entityA.setTypes(newTypes);
887: final String newStringAtt = "newStringAttribute";
888: entityA.setStringAttribute(newStringAtt);
889:
890: em.getTransaction().begin();
891: final OWLClassA merged = em.merge(entityA);
892: assertEquals(newStringAtt, merged.getStringAttribute());
893: assertTrue(TestEnvironmentUtils.typesEqual(newTypes, merged.getTypes()));
894: em.getTransaction().commit();
895:
896: final OWLClassA result = findRequired(OWLClassA.class, entityA.getUri());
897: assertEquals(newStringAtt, result.getStringAttribute());
898: assertTrue(TestEnvironmentUtils.typesEqual(newTypes, result.getTypes()));
899: }
900:
901: @Test
902: void mergeMergesUpdateToObjectPropertyField() {
903: this.em = getEntityManager("mergeMergesUpdateToObjectPropertyField", true);
904: persist(entityD, entityA, entityA2);
905:
906: em.getTransaction().begin();
907: entityD.setOwlClassA(entityA2);
908: final OWLClassD merged = em.merge(entityD);
909: assertEquals(entityA2.getUri(), merged.getOwlClassA().getUri());
910: em.getTransaction().commit();
911:
912: final OWLClassD dResult = findRequired(OWLClassD.class, entityD.getUri());
913: assertEquals(entityA2.getUri(), dResult.getOwlClassA().getUri());
914: final OWLClassA aReference = findRequired(OWLClassA.class, entityA2.getUri());
915: assertSame(dResult.getOwlClassA(), aReference);
916: assertNotNull(em.find(OWLClassA.class, entityA.getUri()));
917: }
918:
919: @Test
920: void updateSupportsSavingStringLiteralWithDifferentLanguageTag() throws Exception {
921: this.em = getEntityManager("updateSupportsSavingStringLiteralWithDifferentLanguageTag", false);
922: persist(entityA);
923:
924: entityA.setStringAttribute("hodnota v cestine");
925: final Descriptor descriptor = new EntityDescriptor();
926: descriptor.setAttributeLanguage(OWLClassA.class.getDeclaredField("stringAttribute"), "cs");
927: em.getTransaction().begin();
928: em.merge(entityA, descriptor);
929: em.getTransaction().commit();
930:
931: final OWLClassA resultOne = findRequired(OWLClassA.class, entityA.getUri());
932: assertNull(resultOne.getStringAttribute());
933: em.clear();
934: final OWLClassA resultTwo = em.find(OWLClassA.class, entityA.getUri(), descriptor);
935: assertEquals(entityA.getStringAttribute(), resultTwo.getStringAttribute());
936: }
937:
938: @Test
939: void mergeDetachedRemovesObsoleteDescriptorInSecondLevelCache() {
940: this.em = getEntityManager("mergeDetachedReplacesObsoleteDescriptorInSecondLevelCache", true);
941: final Descriptor descriptorOne = new EntityDescriptor();
942: descriptorOne.setLanguage("en");
943: em.getTransaction().begin();
944: em.persist(entityA, descriptorOne);
945: em.getTransaction().commit();
946: assertTrue(em.getEntityManagerFactory().getCache().contains(OWLClassA.class, entityA.getUri(), descriptorOne));
947:
948: final Descriptor descriptorTwo = new EntityDescriptor();
949: descriptorTwo.setLanguage("cs");
950: assertNotEquals(descriptorOne, descriptorTwo);
951: entityA.setStringAttribute("cesky");
952: em.getTransaction().begin();
953: em.merge(entityA, descriptorTwo);
954: em.getTransaction().commit();
955:
956: assertFalse(em.getEntityManagerFactory().getCache().contains(OWLClassA.class, entityA.getUri(), descriptorOne));
957: final OWLClassA result = em.find(OWLClassA.class, entityA.getUri(), descriptorTwo);
958: assertEquals(entityA.getStringAttribute(), result.getStringAttribute());
959: assertTrue(em.getEntityManagerFactory().getCache().contains(OWLClassA.class, entityA.getUri(), descriptorTwo));
960: }
961:
962: @Test
963: void mergeUpdatesCacheEventWhenDescriptorContainsOnlyAttributeLanguageSetting() throws Exception {
964: this.em = getEntityManager("mergeUpdatesCacheEventWhenDescriptorContainsOnlyAttributeLanguageSetting", true);
965: persist(entityA);
966:
967: final Descriptor descriptorTwo = new EntityDescriptor();
968: descriptorTwo.setAttributeLanguage(OWLClassA.class.getDeclaredField("stringAttribute"), "cs");
969: entityA.setStringAttribute("cesky");
970: em.getTransaction().begin();
971: em.merge(entityA, descriptorTwo);
972: em.getTransaction().commit();
973:
974: final OWLClassA result = em.find(OWLClassA.class, entityA.getUri(), descriptorTwo);
975: assertEquals(entityA.getStringAttribute(), result.getStringAttribute());
976: assertTrue(em.getEntityManagerFactory().getCache().contains(OWLClassA.class, entityA.getUri(), descriptorTwo));
977: }
978:
979: @Test
980: void updateRemovesPendingAssertionWhenItIsReplacedByAnotherValue() {
981: this.em = getEntityManager("updateRemovesPendingAssertionWhenItIsReplacedByAnotherValue", true);
982: entityD.setOwlClassA(null);
983: persist(entityD, entityA2);
984:
985: em.getTransaction().begin();
986: final OWLClassD d = findRequired(OWLClassD.class, entityD.getUri());
987: d.setOwlClassA(entityA);
988: d.setOwlClassA(findRequired(OWLClassA.class, entityA2.getUri()));
989: em.getTransaction().commit();
990:
991: final OWLClassD dResult = findRequired(OWLClassD.class, entityD.getUri());
992: assertNotNull(dResult.getOwlClassA());
993: assertEquals(entityA2.getUri(), dResult.getOwlClassA().getUri());
994: assertNull(em.find(OWLClassA.class, entityA.getUri()));
995: }
996:
997: @Test
998: void updatesKeepsPendingAssertionPluralAttribute() {
999: this.em = getEntityManager("updatesKeepsPendingAssertionPluralAttribute", true);
1000: final OWLClassL entityL = new OWLClassL(Generators.generateUri());
1001: entityL.setSet(new HashSet<>());
1002: entityL.getSet().add(entityA2);
1003: entityL.setSimpleList(Collections.singletonList(entityA2));
1004: entityL.setSingleA(entityA2);
1005: entityL.setUri(Generators.generateUri());
1006: persist(entityL, entityA2);
1007:
1008: em.getTransaction().begin();
1009: final OWLClassL inst = findRequired(OWLClassL.class, entityL.getUri());
1010: inst.getSet().add(entityA);
1011: final RollbackException ex = assertThrows(RollbackException.class, () -> em.getTransaction().commit());
1012: assertThat(ex.getCause(), instanceOf(UnpersistedChangeException.class));
1013: assertThat(ex.getMessage(), containsString(entityA.toString()));
1014: }
1015:
1016: @Test
1017: void mergeCorrectlyUpdatesCacheInCaseOfChangeInReferencedAttributePreviouslyMerged() {
1018: this.em = getEntityManager("mergeCorrectlyUpdatesCacheInCaseOfChangeInReferencedAttributePreviouslyMerged",
1019: true);
1020: persist(entityD, entityA);
1021:
1022: final String newString = "updatedString";
1023: final OWLClassD dUpdate = new OWLClassD(entityD.getUri());
1024: final OWLClassA aUpdate = new OWLClassA(entityA.getUri());
1025: aUpdate.setStringAttribute(newString);
1026: aUpdate.setTypes(new HashSet<>(entityA.getTypes()));
1027: dUpdate.setOwlClassA(aUpdate);
1028: em.clear();
1029: em.getTransaction().begin();
1030: final OWLClassD orig = findRequired(OWLClassD.class, entityD.getUri());
1031: em.detach(orig);
1032: em.find(OWLClassA.class, entityA.getUri());
1033: em.merge(aUpdate);
1034: em.merge(dUpdate);
1035: em.getTransaction().commit();
1036: final OWLClassD result = findRequired(OWLClassD.class, entityD.getUri());
1037: assertEquals(newString, result.getOwlClassA().getStringAttribute());
1038: }
1039:
1040: @Test
1041: void mergeCorrectlyUpdatesCacheInCaseOfChangeInReferencedAttributeMergedLater() {
1042: this.em = getEntityManager("mergeCorrectlyUpdatesCacheInCaseOfChangeInReferencedAttributeMergedLater",
1043: true);
1044: persist(entityD, entityA);
1045:
1046: final String newString = "updatedString";
1047: final OWLClassD dUpdate = new OWLClassD(entityD.getUri());
1048: final OWLClassA aUpdate = new OWLClassA(entityA.getUri());
1049: aUpdate.setStringAttribute(newString);
1050: aUpdate.setTypes(new HashSet<>(entityA.getTypes()));
1051: dUpdate.setOwlClassA(aUpdate);
1052: em.clear();
1053: em.getTransaction().begin();
1054: final OWLClassD orig = findRequired(OWLClassD.class, entityD.getUri());
1055: em.detach(orig);
1056: em.merge(dUpdate);
1057: em.merge(aUpdate);
1058: em.getTransaction().commit();
1059: final OWLClassD result = findRequired(OWLClassD.class, entityD.getUri());
1060: assertEquals(newString, result.getOwlClassA().getStringAttribute());
1061: }
1062:
1063: @Test
1064: void mergeCorrectlyMergesChangesOnPluralObjectPropertyIntoCache() {
1065: this.em = getEntityManager("mergeCorrectlyMergesChangesOnPluralObjectPropertyIntoCache", true);
1066: final OWLClassL entityL = new OWLClassL(Generators.generateUri());
1067: entityL.setSet(new HashSet<>());
1068: entityL.getSet().add(entityA);
1069: entityL.getSet().add(entityA2);
1070: entityL.setSimpleList(Collections.singletonList(entityA2));
1071: entityL.setSingleA(entityA2);
1072: persist(entityL, entityA, entityA2);
1073:
1074: final OWLClassL toUpdate = new OWLClassL(entityL.getUri());
1075: toUpdate.setSet(new HashSet<>(entityL.getSet()));
1076: toUpdate.getSet().remove(entityA2);
1077: toUpdate.setSimpleList(Collections.singletonList(entityA2));
1078: toUpdate.setSingleA(entityA2);
1079: em.getTransaction().begin();
1080: final OWLClassL original = findRequired(OWLClassL.class, entityL.getUri());
1081: assertEquals(2, original.getSet().size());
1082: for (OWLClassA a : original.getSet()) {
1083: if (a.getUri().equals(entityA2.getUri())) {
1084: original.getSet().remove(a);
1085: break;
1086: }
1087: }
1088: toUpdate.getSet().forEach(a -> em.merge(a));
1089: em.merge(toUpdate);
1090: em.getTransaction().commit();
1091:
1092: final OWLClassL result = findRequired(OWLClassL.class, entityL.getUri());
1093: assertEquals(1, result.getSet().size());
1094: }
1095:
1096: @Test
1097: void updateKeepsPendingListReferenceWhenItemIsAddedToIt() {
1098: this.em = getEntityManager("updateKeepsPendingListReferenceWhenItemIsAddedToIt", true);
1099: final OWLClassK entityK = new OWLClassK();
1100: entityK.setSimpleList(generateEInstances(5));
1101: entityK.setReferencedList(generateEInstances(6));
1102: em.getTransaction().begin();
1103: em.persist(entityK);
1104: entityK.getSimpleList().forEach(e -> {
1105: assertNull(e.getUri());
1106: em.persist(e);
1107: });
1108: entityK.getReferencedList().forEach(e -> {
1109: assertNull(e.getUri());
1110: em.persist(e);
1111: });
1112: em.getTransaction().commit();
1113:
1114: final OWLClassE addedSimple = new OWLClassE();
1115: addedSimple.setStringAttribute("addedSimple");
1116: final OWLClassE addedReferenced = new OWLClassE();
1117: addedReferenced.setStringAttribute("addedReferenced");
1118: em.getTransaction().begin();
1119: final OWLClassK update = em.find(OWLClassK.class, entityK.getUri());
1120: update.getSimpleList().add(addedSimple);
1121: update.getReferencedList().add(addedReferenced);
1122: assertNull(addedSimple.getUri());
1123: assertNull(addedReferenced.getUri());
1124: em.persist(addedSimple);
1125: em.persist(addedReferenced);
1126: em.getTransaction().commit();
1127:
1128: final OWLClassK result = findRequired(OWLClassK.class, entityK.getUri());
1129: assertEquals(addedSimple.getUri(), result.getSimpleList().get(result.getSimpleList().size() - 1).getUri());
1130: assertEquals(addedReferenced.getUri(),
1131: result.getReferencedList().get(result.getReferencedList().size() - 1).getUri());
1132: }
1133:
1134: private List<OWLClassE> generateEInstances(int count) {
1135: return IntStream.range(0, count).mapToObj(i -> {
1136: final OWLClassE e = new OWLClassE();
1137: e.setStringAttribute("instance" + i);
1138: return e;
1139: }).collect(Collectors.toList());
1140: }
1141:
1142: @Test
1143: void mergeRemovedThrowsIllegalArgumentException() {
1144: this.em = getEntityManager("mergeRemovedThrowsIllegalArgument", true);
1145: persist(entityA);
1146:
1147: em.getTransaction().begin();
1148: final OWLClassA toRemove = findRequired(OWLClassA.class, entityA.getUri());
1149: em.remove(toRemove);
1150: final IllegalArgumentException ex = assertThrows(IllegalArgumentException.class, () -> em.merge(toRemove));
1151: assertThat(ex.getMessage(), containsString("removed"));
1152: }
1153:
1154: @Test
1155: void changesDoneAfterInstanceRefreshAreCommittedToRepository() {
1156: this.em = getEntityManager("changesDoneAfterInstanceRefreshAreCommittedToRepository", true);
1157: persist(entityD, entityA, entityA2);
1158:
1159: em.getTransaction().begin();
1160: final OWLClassD d = findRequired(OWLClassD.class, entityD.getUri());
1161: final OWLClassA origA = d.getOwlClassA();
1162: final OWLClassA newA = new OWLClassA(Generators.generateUri());
1163: newA.setStringAttribute("newAWithStringAttribute");
1164: d.setOwlClassA(em.find(OWLClassA.class, entityA2.getUri()));
1165: em.refresh(d);
1166: assertEquals(origA, d.getOwlClassA());
1167: d.setOwlClassA(newA);
1168: em.persist(newA);
1169: em.getTransaction().commit();
1170:
1171: final OWLClassD result = findRequired(OWLClassD.class, entityD.getUri());
1172: assertEquals(newA.getUri(), result.getOwlClassA().getUri());
1173: assertEquals(newA.getStringAttribute(), result.getOwlClassA().getStringAttribute());
1174: }
1175:
1176: @Test
1177: void refreshOfPluralObjectPropertyReplacesCollectionWithOriginalAndAllowsFurtherChanges() {
1178: this.em = getEntityManager("refreshOfPluralObjectPropertyReplacesCollectionWithOriginalAndAllowsFurtherChanges",
1179: true);
1180: persist(entityJ);
1181:
1182: em.getTransaction().begin();
1183: final OWLClassJ j = findRequired(OWLClassJ.class, entityJ.getUri());
1184: j.getOwlClassA().clear();
1185: em.refresh(j);
1186: final OWLClassA newA = new OWLClassA(Generators.generateUri());
1187: newA.setStringAttribute("newAWithStringAttribute");
1188: j.getOwlClassA().add(newA);
1189: em.persist(newA);
1190: em.getTransaction().commit();
1191:
1192: final OWLClassJ result = findRequired(OWLClassJ.class, entityJ.getUri());
1193: assertEquals(entityJ.getOwlClassA().size() + 1, result.getOwlClassA().size());
1194: final Set<URI> aUris = new HashSet<>(Arrays.asList(entityA.getUri(), entityA2.getUri(), newA.getUri()));
1195: result.getOwlClassA().forEach(a -> assertTrue(aUris.contains(a.getUri())));
1196: }
1197:
1198: /**
1199: * Bug #33
1200: */
1201: @Test
1202: void mergeWithUpdatedPropertyValueRemovesOriginalAssertion() {
1203: this.em = getEntityManager("mergeWithUpdatedPropertyValueRemovesOriginalAssertion", false);
1204: persist(entityH, entityA);
1205:
1206: em.getTransaction().begin();
1207: entityH.setOwlClassA(entityA2);
1208: em.merge(entityH);
1209: em.getTransaction().commit();
1210:
1211: final OWLClassH result = findRequired(OWLClassH.class, entityH.getUri());
1212: assertEquals(entityA2.getUri(), result.getOwlClassA().getUri());
1213: assertNotNull(em.find(OWLClassA.class, entityA.getUri()));
1214: }
1215:
1216: /**
1217: * Bug #33, but for plural attributes
1218: */
1219: @Test
1220: void mergeWithUpdatedPropertyValueRemovesOriginalAssertionsFromPluralAttribute() {
1221: this.em = getEntityManager("mergeWithUpdatedPropertyValueRemovesOriginalAssertionsFromPluralAttribute", false);
1222: persist(entityJ);
1223:
1224: assertEquals(2, entityJ.getOwlClassA().size());
1225: final OWLClassA newA = new OWLClassA(Generators.generateUri());
1226: entityJ.setOwlClassA(Collections.singleton(newA));
1227: em.getTransaction().begin();
1228: em.merge(entityJ);
1229: em.getTransaction().commit();
1230:
1231: final OWLClassJ result = findRequired(OWLClassJ.class, entityJ.getUri());
1232: assertEquals(1, result.getOwlClassA().size());
1233: assertEquals(newA.getUri(), result.getOwlClassA().iterator().next().getUri());
1234: }
1235:
1236: @Test
1237: void updateSupportsJava8Instant() {
1238: this.em = getEntityManager("updateSupportsJava8Instant", true);
1239: final OWLClassX entityX = new OWLClassX();
1240: entityX.setInstant(Instant.now());
1241: persist(entityX);
1242:
1243: final Instant newInstant = Instant.ofEpochMilli(System.currentTimeMillis() + 10000);
1244: em.getTransaction().begin();
1245: final OWLClassX toUpdate = findRequired(OWLClassX.class, entityX.getUri());
1246: toUpdate.setInstant(newInstant);
1247: em.getTransaction().commit();
1248:
1249: final OWLClassX cachedResult = findRequired(OWLClassX.class, entityX.getUri());
1250: assertEquals(newInstant, cachedResult.getInstant());
1251: em.getEntityManagerFactory().getCache().evict(OWLClassX.class);
1252: final OWLClassX result = findRequired(OWLClassX.class, entityX.getUri());
1253: assertEquals(newInstant, result.getInstant());
1254: }
1255:
1256: @Test
1257: void updateSupportsPluralAnnotationProperty() {
1258: this.em = getEntityManager("updateSupportsPluralAnnotationProperty", true);
1259: final Set<String> annotations = IntStream.range(0, 5).mapToObj(i -> "Source" + i).collect(Collectors.toSet());
1260: entityN.setPluralAnnotationProperty(annotations);
1261: persist(entityN);
1262:
1263: final String added = "Added Source";
1264: final String removed = annotations.iterator().next();
1265: annotations.remove(removed);
1266: annotations.add(added);
1267: entityN.getPluralAnnotationProperty().remove(removed);
1268: entityN.getPluralAnnotationProperty().add(added);
1269: em.getTransaction().begin();
1270: final OWLClassN merged = em.merge(entityN);
1271: assertEquals(annotations, merged.getPluralAnnotationProperty());
1272: em.getTransaction().commit();
1273:
1274: final OWLClassN result = findRequired(OWLClassN.class, entityN.getId());
1275: assertEquals(annotations, result.getPluralAnnotationProperty());
1276: }
1277:
1278: @Test
1279: void updateSupportsSettingSubclassOnPolymorphicAttribute() {
1280: this.em = getEntityManager("updateSupportsSettingSubclassOnPolymorphicAttribute", true);
1281: final OWLClassU u = new OWLClassU();
1282: final OWLClassU reference = new OWLClassU();
1283: em.getTransaction().begin();
1284: em.persist(reference);
1285: em.getTransaction().commit();
1286:
1287: em.getTransaction().begin();
1288: final OWLClassU managedRef = em.merge(reference);
1289: u.setOwlClassS(managedRef);
1290: em.persist(u);
1291: em.getTransaction().commit();
1292:
1293: final OWLClassU result = findRequired(OWLClassU.class, u.getUri());
1294: assertEquals(reference.getUri(), result.getOwlClassS().getUri());
1295: }
1296:
1297: @Test
1298: void updateSupportsUpdatingSimpleLiteralValue() {
1299: this.em = getEntityManager("updateSupportsUpdatingSimpleLiteralValue", true);
1300: entityM.setSimpleLiteral("test original");
1301: persist(entityM);
1302:
1303: updateSimpleLiteralAndVerify();
1304: }
1305:
1306: private void updateSimpleLiteralAndVerify() {
1307: em.getTransaction().begin();
1308: final String newValue = "new test value";
1309: final OWLClassM toUpdate = findRequired(OWLClassM.class, entityM.getKey());
1310: toUpdate.setSimpleLiteral(newValue);
1311: em.getTransaction().commit();
1312:
1313: verifyValueDatatype(URI.create(entityM.getKey()), Vocabulary.p_m_simpleLiteral, XSD.STRING);
1314: final OWLClassM result = findRequired(OWLClassM.class, entityM.getKey());
1315: assertEquals(newValue, result.getSimpleLiteral());
1316: }
1317:
1318: @Test
1319: void updateOverwritesLanguageStringWithSimpleLiteralForSimpleLiteralAttribute() throws Exception {
1320: this.em = getEntityManager("updateOverwritesLanguageStringWithSimpleLiteralForSimpleLiteralAttribute", true);
1321: persist(entityM);
1322: final Collection<Quad> originalQuad = Collections.singleton(
1323: new Quad(URI.create(entityM.getKey()), URI.create(Vocabulary.p_m_simpleLiteral), "test", "en"));
1324: persistTestData(originalQuad, em);
1325:
1326: updateSimpleLiteralAndVerify();
1327: verifyStatementsNotPresent(originalQuad, em);
1328: }
1329: }