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