![[Jenkins]](/jenkins/static/e13cae7a/images/svgs/logo.svg){kind=logo}
Package: UpdateOperationsRunner
UpdateOperationsRunner
| name | instruction | branch | complexity | line | method | ||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| UpdateOperationsRunner(Logger) |
|
|
|
|
|
||||||||||||||||||||
| addingValuesToDatatypePropertyCollectionAddsThemIntoRepository() |
|
|
|
|
|
||||||||||||||||||||
| generateValueForProperty(OWLClassP, URI) |
|
|
|
|
|
||||||||||||||||||||
| initialize() |
|
|
|
|
|
||||||||||||||||||||
| lambda$0(OWLClassA) |
|
|
|
|
|
||||||||||||||||||||
| mergeMergesUpdateToObjectPropertyField() |
|
|
|
|
|
||||||||||||||||||||
| mergeMergesUpdatedDataPropertyFields() |
|
|
|
|
|
||||||||||||||||||||
| mergeReplacesReferenceWithInstanceFromRepository() |
|
|
|
|
|
||||||||||||||||||||
| mergedInstanceWithChangesInCascadedPluralReferenceAttributeContainsUpdatedValues() |
|
|
|
|
|
||||||||||||||||||||
| modificationsOfCollectionAfterCascadeMergeAreWrittenOnCommit() |
|
|
|
|
|
||||||||||||||||||||
| persistEntityWithList() |
|
|
|
|
|
||||||||||||||||||||
| 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() |
|
|
|
|
|
||||||||||||||||||||
| updateWithInvalidInstanceThrowsIntegrityConstraintsViolation() |
|
|
|
|
|
||||||||||||||||||||
Coverage
1: /**
2: * Copyright (C) 2016 Czech Technical University in Prague
3: * <p>
4: * This program is free software: you can redistribute it and/or modify it under
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: * <p>
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.IntegrityConstraintViolatedException;
18: import cz.cvut.kbss.jopa.exceptions.OWLInferredAttributeModifiedException;
19: import cz.cvut.kbss.jopa.exceptions.RollbackException;
20: import cz.cvut.kbss.jopa.test.*;
21: import cz.cvut.kbss.jopa.test.environment.Generators;
22: import cz.cvut.kbss.jopa.test.environment.TestEnvironmentUtils;
23: import org.junit.Test;
24: import org.slf4j.Logger;
25:
26: import java.lang.reflect.Field;
27: import java.net.MalformedURLException;
28: import java.net.URI;
29: import java.net.URL;
30: import java.util.*;
31: import java.util.stream.Collectors;
32: import java.util.stream.IntStream;
33:
34: import static org.hamcrest.core.Is.isA;
35: import static org.junit.Assert.*;
36:
37: public abstract class UpdateOperationsRunner extends BaseRunner {
38:
39: private OWLClassA entityA2;
40: private OWLClassF entityF;
41: private OWLClassJ entityJ;
42: private OWLClassO entityO;
43:
44: public UpdateOperationsRunner(Logger logger) {
45: super(logger);
46: initialize();
47: }
48:
49: private void initialize() {
50: this.entityF = new OWLClassF();
51: entityF.setUri(URI.create("http://krizik.felk.cvut.cz/ontologies/jopa/tests/entityF"));
52: this.entityA2 = new OWLClassA();
53: entityA2.setUri(URI.create("http://krizik.felk.cvut.cz/ontologies/jopa/tests/entityA2"));
54: this.entityJ = new OWLClassJ();
55: entityJ.setUri(URI.create("http://krizik.felk.cvut.cz/ontologies/jopa/tests/entityJ"));
56: final Set<OWLClassA> set = new HashSet<>(2);
57: set.add(entityA);
58: set.add(entityA2);
59: entityJ.setOwlClassA(set);
60: this.entityO = new OWLClassO(URI.create("http://krizik.felk.cvut.cz/ontologies/jopa/tests/entityO"));
61: final Set<OWLClassE> es = new HashSet<>();
62:• for (int i = 0; i < 5; i++) {
63: final OWLClassE e = new OWLClassE();
64: e.setStringAttribute("StringAttributeNo" + i);
65: es.add(e);
66: }
67: entityO.setOwlClassESet(es);
68: }
69:
70: @Test
71: public void testUpdateDataLeaveLazy() throws Exception {
72: logger.debug(
73: "Test: update data property. Leaves lazily loaded field empty and checks that after commit the field's value hasn't changed.");
74: this.em = getEntityManager("UpdateDataProperty", false);
75: entityB.setProperties(Generators.createProperties());
76: persist(entityB);
77:
78: em.getTransaction().begin();
79: final OWLClassB b = em.find(OWLClassB.class, entityB.getUri());
80: assertNotNull(b);
81: final Field propsField = OWLClassB.class.getDeclaredField("properties");
82: propsField.setAccessible(true);
83: assertNull(propsField.get(b));
84: final String newString = "NewString";
85: b.setStringAttribute(newString);
86: em.getTransaction().commit();
87:
88: final OWLClassB res = em.find(OWLClassB.class, entityB.getUri());
89: assertNotNull(res);
90: assertEquals(newString, res.getStringAttribute());
91: assertNotNull(res.getProperties());
92: assertEquals(entityB.getProperties(), res.getProperties());
93: }
94:
95: @Test
96: public void testUpdateDataPropertySetNull() {
97: logger.debug("Test: update data property. Set it to null.");
98: this.em = getEntityManager("UpdateDataPropertyToNull", true);
99: persist(entityA);
100:
101: em.getTransaction().begin();
102: final OWLClassA a = em.find(OWLClassA.class, entityA.getUri());
103: assertNotNull(a);
104: assertNotNull(a.getStringAttribute());
105: a.setStringAttribute(null);
106: em.getTransaction().commit();
107:
108: final OWLClassA res = em.find(OWLClassA.class, entityA.getUri());
109: assertNotNull(res);
110: assertNull(res.getStringAttribute());
111: assertEquals(entityA.getTypes(), res.getTypes());
112: }
113:
114: @Test
115: public void testUpdateReference() {
116: logger.debug("Test: update reference to entity.");
117: this.em = getEntityManager("UpdateReference", true);
118: persist(entityD, entityI);
119: // em.persist(entityA, ctx);
120:
121: final OWLClassA newA = new OWLClassA();
122: newA.setUri(URI.create("http://krizik.felk.cvut.cz/ontologies/jopa/tests/newEntityA"));
123: newA.setStringAttribute("newA");
124: em.getTransaction().begin();
125: final OWLClassD d = em.find(OWLClassD.class, entityD.getUri());
126: assertNotNull(d.getOwlClassA());
127: d.setOwlClassA(newA);
128: final OWLClassI i = em.find(OWLClassI.class, entityI.getUri());
129: assertNotNull(i.getOwlClassA());
130: i.setOwlClassA(newA);
131: em.persist(newA);
132: em.getTransaction().commit();
133:
134: final OWLClassA resA1 = em.find(OWLClassA.class, newA.getUri());
135: assertNotNull(resA1);
136: final OWLClassD resD = em.find(OWLClassD.class, d.getUri());
137: assertEquals(resA1.getUri(), resD.getOwlClassA().getUri());
138: // assertSame(resD.getOwlClassA(), resA1);
139: assertNotNull(em.find(OWLClassA.class, entityA.getUri()));
140: final OWLClassI resI = em.find(OWLClassI.class, i.getUri());
141: assertEquals(newA.getUri(), resI.getOwlClassA().getUri());
142: assertNotNull(em.find(OWLClassA.class, entityA.getUri()));
143: assertEquals(resA1.getUri(), resI.getOwlClassA().getUri());
144: // assertEquals(resA1, resI.getOwlClassA());
145: }
146:
147: @Test
148: public void mergedInstanceWithChangesInCascadedPluralReferenceAttributeContainsUpdatedValues()
149: throws Exception {
150: this.em = getEntityManager("MergeSet", false);
151: persist(entityJ);
152: em.clear();
153:
154: entityJ.getOwlClassA().forEach(a -> a.setStringAttribute("NEWVALUE"));
155:
156: em.getTransaction().begin();
157: OWLClassJ merged = em.merge(entityJ);
158:
159:• for (final OWLClassA a : merged.getOwlClassA()) {
160: assertEquals(a.getStringAttribute(), "NEWVALUE");
161: }
162: em.getTransaction().commit();
163: }
164:
165: @Test
166: public void testMergeDetachedWithChanges() {
167: logger.debug("Test: merge detached entity with changes.");
168: this.em = getEntityManager("UpdateDetached", true);
169: persist(entityA);
170:
171: final OWLClassA a = em.find(OWLClassA.class, entityA.getUri());
172: assertTrue(em.contains(a));
173: em.detach(a);
174: assertFalse(em.contains(a));
175: final String newType = "http://krizik.felk.cvut.cz/ontologies/jopa/entities#AddedType";
176: a.getTypes().add(newType);
177: em.getTransaction().begin();
178: final OWLClassA merged = em.merge(a);
179: assertTrue(merged.getTypes().contains(newType));
180: em.getTransaction().commit();
181:
182: final OWLClassA res = em.find(OWLClassA.class, a.getUri());
183: assertEquals(a.getTypes().size(), res.getTypes().size());
184: assertTrue(res.getTypes().containsAll(a.getTypes()));
185: }
186:
187: @Test
188: public void testMergeDetachedCascade() {
189: logger.debug("Test: merge detached with cascade.");
190: this.em = getEntityManager("UpdateCascade", true);
191: em.getTransaction().begin();
192: em.persist(entityH);
193: assertTrue(em.contains(entityA));
194: em.getTransaction().commit();
195:
196: em.getTransaction().begin();
197: final OWLClassH h = em.find(OWLClassH.class, entityH.getUri());
198: assertNotNull(h.getOwlClassA());
199: em.detach(h);
200: assertFalse(em.contains(h));
201: assertFalse(em.contains(h.getOwlClassA()));
202: final String newStr = "newStringAttribute";
203: h.getOwlClassA().setStringAttribute(newStr);
204: final OWLClassH merged = em.merge(h);
205: assertEquals(newStr, merged.getOwlClassA().getStringAttribute());
206: em.getTransaction().commit();
207:
208: final OWLClassA res = em.find(OWLClassA.class, entityA.getUri());
209: assertNotNull(res);
210: assertEquals(newStr, res.getStringAttribute());
211: }
212:
213: @Test
214: public void testMergeDetachedWithObjectPropertyChange() {
215: logger.debug("Test: merge detached with object property change.");
216: this.em = getEntityManager("UpdateDetachedWithOPChange", true);
217: persist(entityD, entityA);
218:
219: final OWLClassD d = em.find(OWLClassD.class, entityD.getUri());
220: em.detach(d);
221: d.setOwlClassA(entityA2);
222: em.getTransaction().begin();
223: em.merge(d);
224: em.persist(entityA2);
225: em.getTransaction().commit();
226:
227: final OWLClassD res = em.find(OWLClassD.class, entityD.getUri());
228: assertNotNull(res);
229: assertEquals(entityA2.getUri(), res.getOwlClassA().getUri());
230: assertEquals(entityA2.getStringAttribute(), res.getOwlClassA().getStringAttribute());
231: final OWLClassA resA = em.find(OWLClassA.class, entityA.getUri());
232: assertNotNull(resA);
233: assertEquals(entityA.getStringAttribute(), resA.getStringAttribute());
234: assertEquals(entityA.getTypes(), resA.getTypes());
235: }
236:
237: @Test
238: public void testRemoveFromSimpleList() {
239: logger.debug("Test: remove entity from simple list. (But keep it in the ontology.)");
240: this.em = getEntityManager("UpdateRemoveFromSimpleList", true);
241: entityC.setSimpleList(Generators.createSimpleList());
242: persistEntityWithList();
243:
244: final OWLClassC c = em.find(OWLClassC.class, entityC.getUri());
245: assertNotNull(c);
246: em.getTransaction().begin();
247: final OWLClassA a = c.getSimpleList().get(1);
248: c.getSimpleList().remove(a);
249: em.getTransaction().commit();
250:
251: final OWLClassA resA = em.find(OWLClassA.class, a.getUri());
252: assertNotNull(resA);
253: final OWLClassC resC = em.find(OWLClassC.class, c.getUri());
254: assertEquals(c.getSimpleList().size(), resC.getSimpleList().size());
255: assertEquals(entityC.getSimpleList().size() - 1, resC.getSimpleList().size());
256:• for (OWLClassA aa : resC.getSimpleList()) {
257: assertFalse(resA.getUri().equals(aa.getUri()));
258: }
259: }
260:
261: private void persistEntityWithList() {
262: em.getTransaction().begin();
263: em.persist(entityC);
264:• if (entityC.getSimpleList() != null) {
265: entityC.getSimpleList().forEach(em::persist);
266: }
267:• if (entityC.getReferencedList() != null) {
268: entityC.getReferencedList().forEach(em::persist);
269: }
270: em.getTransaction().commit();
271: }
272:
273: @Test
274: public void testAddToSimpleList() {
275: logger.debug("Test: add entity to simple list.");
276: this.em = getEntityManager("UpdateAddToSimpleList", true);
277: entityC.setSimpleList(Generators.createSimpleList());
278: em.getTransaction().begin();
279: em.persist(entityC);
280: entityC.getSimpleList().forEach(em::persist);
281: em.persist(entityA);
282: em.getTransaction().commit();
283:
284: em.getTransaction().begin();
285: final OWLClassC c = em.find(OWLClassC.class, entityC.getUri());
286: assertNotNull(c);
287: final OWLClassA a = em.find(OWLClassA.class, entityA.getUri());
288: assertNotNull(a);
289: assertFalse(c.getSimpleList().contains(a));
290: c.getSimpleList().add(a);
291: em.getTransaction().commit();
292:
293: final OWLClassC resC = em.find(OWLClassC.class, entityC.getUri());
294: assertEquals(c.getSimpleList().size(), resC.getSimpleList().size());
295: assertEquals(entityC.getSimpleList().size() + 1, resC.getSimpleList().size());
296: final OWLClassA resA = em.find(OWLClassA.class, entityA.getUri());
297: assertNotNull(resA);
298: assertTrue(resC.getSimpleList().contains(resA));
299: }
300:
301: @Test
302: public void testClearSimpleList() {
303: logger.debug("Test: clear a simple list (but keep the entities in ontology).");
304: this.em = getEntityManager("UpdateClearSimpleList", true);
305: entityC.setSimpleList(Generators.createSimpleList());
306: persistEntityWithList();
307:
308: final OWLClassC c = em.find(OWLClassC.class, entityC.getUri());
309: assertNotNull(c);
310: assertFalse(c.getSimpleList().isEmpty());
311: em.getTransaction().begin();
312: c.getSimpleList().clear();
313: em.getTransaction().commit();
314:
315: final OWLClassC resC = em.find(OWLClassC.class, entityC.getUri());
316: assertNotNull(resC);
317:• assertTrue(resC.getSimpleList() == null || resC.getSimpleList().isEmpty());
318:• for (OWLClassA a : entityC.getSimpleList()) {
319: assertNotNull(em.find(OWLClassA.class, a.getUri()));
320: }
321: }
322:
323: @Test
324: public void testReplaceSimpleList() {
325: logger.debug("Test: replace simple list with a new one.");
326: this.em = getEntityManager("UpdateReplaceSimpleList", true);
327: entityC.setSimpleList(Generators.createSimpleList());
328: persistEntityWithList();
329:
330: final OWLClassC c = em.find(OWLClassC.class, entityC.getUri());
331: final List<OWLClassA> newList = new ArrayList<>(1);
332: newList.add(entityA);
333: em.getTransaction().begin();
334: em.persist(entityA);
335: c.setSimpleList(newList);
336: em.getTransaction().commit();
337:
338: final OWLClassC resC = em.find(OWLClassC.class, entityC.getUri());
339: assertNotNull(resC);
340: assertEquals(newList.size(), resC.getSimpleList().size());
341: boolean found;
342:• for (OWLClassA a : newList) {
343: found = false;
344:• for (OWLClassA aa : resC.getSimpleList()) {
345:• if (a.getUri().equals(aa.getUri())) {
346: found = true;
347: break;
348: }
349: }
350: assertTrue(found);
351: }
352:• for (OWLClassA a : entityC.getSimpleList()) {
353: assertNotNull(em.find(OWLClassA.class, a.getUri()));
354: }
355: }
356:
357: @Test
358: public void testRemoveFromReferencedList() {
359: logger.debug("Test: remove entity from referenced list. (But keep it in the ontology.");
360: this.em = getEntityManager("UpdateRemoveFromReferencedList", true);
361: entityC.setReferencedList(Generators.createReferencedList());
362: persistEntityWithList();
363:
364: final OWLClassC c = em.find(OWLClassC.class, entityC.getUri());
365: assertNotNull(c);
366: em.getTransaction().begin();
367: final OWLClassA a = c.getReferencedList().get(Generators.randomInt(c.getReferencedList().size()));
368: c.getReferencedList().remove(a);
369: em.getTransaction().commit();
370:
371: final OWLClassA resA = em.find(OWLClassA.class, a.getUri());
372: assertNotNull(resA);
373: final OWLClassC resC = em.find(OWLClassC.class, c.getUri());
374: assertEquals(c.getReferencedList().size(), resC.getReferencedList().size());
375: assertEquals(entityC.getReferencedList().size() - 1, resC.getReferencedList().size());
376:• for (OWLClassA aa : resC.getReferencedList()) {
377: assertFalse(resA.getUri().equals(aa.getUri()));
378: }
379: }
380:
381: @Test
382: public void testAddToReferencedList() {
383: logger.debug("Test: add entity to Referenced list.");
384: this.em = getEntityManager("UpdateAddToReferencedList", true);
385: entityC.setReferencedList(Generators.createReferencedList());
386: persistEntityWithList();
387:
388: em.getTransaction().begin();
389: final OWLClassC c = em.find(OWLClassC.class, entityC.getUri());
390: assertNotNull(c);
391: em.persist(entityA);
392: c.getReferencedList().add(entityA);
393: em.getTransaction().commit();
394:
395: final OWLClassC resC = em.find(OWLClassC.class, entityC.getUri());
396: assertEquals(c.getReferencedList().size(), resC.getReferencedList().size());
397: assertEquals(entityC.getReferencedList().size() + 1, resC.getReferencedList().size());
398: final OWLClassA resA = em.find(OWLClassA.class, entityA.getUri());
399: assertNotNull(resA);
400: assertTrue(resC.getReferencedList().contains(resA));
401: }
402:
403: @Test
404: public void testClearReferencedList() {
405: logger.debug("Test: clear referenced list (but keep the entities in ontology).");
406: this.em = getEntityManager("UpdateClearReferencedList", true);
407: entityC.setReferencedList(Generators.createReferencedList());
408: persistEntityWithList();
409:
410: final OWLClassC c = em.find(OWLClassC.class, entityC.getUri());
411: assertNotNull(c);
412: assertFalse(c.getReferencedList().isEmpty());
413: em.getTransaction().begin();
414: c.setReferencedList(null);
415: em.getTransaction().commit();
416:
417: final OWLClassC resC = em.find(OWLClassC.class, entityC.getUri());
418: assertNotNull(resC);
419: assertNull(resC.getReferencedList());
420:• for (OWLClassA a : entityC.getReferencedList()) {
421: assertNotNull(em.find(OWLClassA.class, a.getUri()));
422: }
423: }
424:
425: @Test
426: public void testReplaceReferencedList() {
427: logger.debug("Test: replace referenced list with a new one.");
428: this.em = getEntityManager("UpdateReplaceReferencedList", true);
429: entityC.setReferencedList(Generators.createReferencedList());
430: persistEntityWithList();
431:
432: final OWLClassC c = em.find(OWLClassC.class, entityC.getUri());
433: final List<OWLClassA> newList = new ArrayList<>(1);
434: newList.add(entityA);
435: em.getTransaction().begin();
436: em.persist(entityA);
437: c.setReferencedList(newList);
438: em.getTransaction().commit();
439:
440: final OWLClassC resC = em.find(OWLClassC.class, entityC.getUri());
441: assertNotNull(resC);
442: assertEquals(newList.size(), resC.getReferencedList().size());
443: boolean found;
444:• for (OWLClassA a : newList) {
445: found = false;
446:• for (OWLClassA aa : resC.getReferencedList()) {
447:• if (a.getUri().equals(aa.getUri())) {
448: found = true;
449: break;
450: }
451: }
452: assertTrue(found);
453: }
454:• for (OWLClassA a : entityC.getReferencedList()) {
455: assertNotNull(em.find(OWLClassA.class, a.getUri()));
456: }
457: }
458:
459: @Test
460: public void testAddNewToProperties() {
461: logger.debug("Test: add a new property value to entity's properties.");
462: this.em = getEntityManager("UpdateAddNewToProperties", false);
463: entityB.setProperties(Generators.createProperties());
464: final Map<String, Set<String>> expected = new HashMap<>(entityB.getProperties().size() + 3);
465: expected.putAll(entityB.getProperties());
466: persist(entityB);
467: em.clear();
468:
469: final OWLClassB b = em.find(OWLClassB.class, entityB.getUri());
470: assertNotNull(b);
471: assertEquals(expected.size(), b.getProperties().size());
472: em.getTransaction().begin();
473: b.getProperties().put("http://krizik.felk.cvut.cz/ontologies/jopa/attributes#propertyFour",
474: Collections.singleton("http://krizik.felk.cvut.cz/ontologies/jopa/Stroustrup"));
475: expected.putAll(b.getProperties());
476: em.getTransaction().commit();
477:
478: final OWLClassB res = em.find(OWLClassB.class, b.getUri());
479: assertNotNull(res);
480: assertEquals(expected.size(), res.getProperties().size());
481:• for (Map.Entry<String, Set<String>> e : expected.entrySet()) {
482: assertTrue(res.getProperties().containsKey(e.getKey()));
483: final Set<String> s = e.getValue();
484: final Set<String> resS = res.getProperties().get(e.getKey());
485: assertEquals(s.size(), resS.size());
486: assertTrue(s.containsAll(resS));
487: }
488: }
489:
490: @Test
491: public void testAddPropertyValue() {
492: logger.debug("Test: add another value to an existing property.");
493: this.em = getEntityManager("UpdateAddPropertyValue", false);
494: entityB.setProperties(Generators.createProperties());
495: final Map<String, Set<String>> expected = new HashMap<>(entityB.getProperties().size() + 3);
496: final String prop = entityB.getProperties().keySet().iterator().next();
497: expected.putAll(entityB.getProperties());
498: persist(entityB);
499: em.clear();
500:
501: final OWLClassB b = em.find(OWLClassB.class, entityB.getUri());
502: assertNotNull(b);
503: assertEquals(expected.size(), b.getProperties().size());
504: em.getTransaction().begin();
505: b.getProperties().get(prop).add("http://krizik.felk.cvut.cz/ontologies/jopa/Stroustrup");
506: expected.putAll(b.getProperties());
507: em.getTransaction().commit();
508:
509: final OWLClassB res = em.find(OWLClassB.class, b.getUri());
510: assertNotNull(res);
511: assertEquals(expected.size(), res.getProperties().size());
512:• for (Map.Entry<String, Set<String>> e : expected.entrySet()) {
513: assertTrue(res.getProperties().containsKey(e.getKey()));
514: final Set<String> s = e.getValue();
515: final Set<String> resS = res.getProperties().get(e.getKey());
516: assertEquals(s.size(), resS.size());
517:• if (e.getKey().equals(prop)) {
518:• assertTrue(s.size() > 1);
519:• for (String val : s) {
520: assertTrue(resS.contains(val));
521: }
522: } else {
523: assertTrue(resS.contains(s.iterator().next()));
524: }
525: }
526: }
527:
528: @Test
529: public void testAddPropertyValueDetached() {
530: logger.debug("Test: add another value to an existing property.");
531: this.em = getEntityManager("UpdateAddPropertyValueDetached", false);
532: entityB.setProperties(Generators.createProperties());
533: final String prop = entityB.getProperties().keySet().iterator().next();
534: final String newPropertyValue = "http://krizik.felk.cvut.cz/ontologies/jopa#newPropertyValue";
535: persist(entityB);
536: em.clear();
537:
538: final OWLClassB b = em.find(OWLClassB.class, entityB.getUri());
539: b.getProperties().get(prop).add(newPropertyValue);
540: em.detach(b);
541: em.getTransaction().begin();
542: em.merge(b);
543: em.getTransaction().commit();
544:
545: final OWLClassB res = em.find(OWLClassB.class, entityB.getUri());
546: assertNotNull(res);
547: assertTrue(res.getProperties().get(prop).contains(newPropertyValue));
548: }
549:
550: @Test
551: public void testAddNewTypedPropertyWithValues() {
552: logger.debug("Test: add a new property with values. Typed.");
553: this.em = getEntityManager("UpdateAddNewToPropertiesTyped", false);
554: entityP.setProperties(Generators.createTypedProperties());
555: persist(entityP);
556: em.clear();
557:
558: final OWLClassP p = em.find(OWLClassP.class, entityP.getUri());
559: em.getTransaction().begin();
560: final URI property = URI.create("http://krizik.felk.cvut.cz/ontologies/jopa#newProperty");
561: p.getProperties().put(property, new HashSet<>(Arrays.asList(1, "Two", new Date())));
562: em.getTransaction().commit();
563:
564: em.clear();
565:
566: final OWLClassP res = em.find(OWLClassP.class, entityP.getUri());
567: assertNotNull(res);
568: assertTrue(res.getProperties().containsKey(property));
569: assertEquals(p.getProperties(), res.getProperties());
570: }
571:
572: @Test
573: public void testAddTypedPropertyValue() {
574: logger.debug("Test: add an existing property value. Typed.");
575: this.em = getEntityManager("UpdateAddPropertyValueTyped", false);
576: entityP.setProperties(Generators.createTypedProperties());
577: persist(entityP);
578: em.clear();
579:
580: final OWLClassP p = em.find(OWLClassP.class, entityP.getUri());
581: em.getTransaction().begin();
582: final URI property = p.getProperties().keySet().iterator().next();
583: final Object value = generateValueForProperty(p, property);
584: p.getProperties().get(property).add(value);
585: em.getTransaction().commit();
586:
587: final OWLClassP res = em.find(OWLClassP.class, entityP.getUri());
588: assertTrue(res.getProperties().get(property).contains(value));
589: assertEquals(p.getProperties(), res.getProperties());
590: }
591:
592: private Object generateValueForProperty(OWLClassP instance, URI property) {
593: final Set<Object> values = instance.getProperties().get(property);
594:• assert values != null && !values.isEmpty();
595:• if (values.iterator().next() instanceof URI) {
596: return URI.create("http://krizik.felk.cvut.cz/ontologies/jopa#newPropertyValue");
597: } else {
598: return "StringValue";
599: }
600: }
601:
602: @Test(expected = OWLInferredAttributeModifiedException.class)
603: public void testModifyInferredAttribute() {
604: logger.debug("Test: modify an inferred attribute.");
605: this.em = getEntityManager("ModifyInferredAttribute", false);
606: persist(entityF);
607:
608: em.getTransaction().begin();
609: final OWLClassF f = em.find(OWLClassF.class, entityF.getUri());
610: assertNotNull(f);
611: f.setSecondStringAttribute("otherValue");
612: em.getTransaction().commit();
613: }
614:
615: @Test
616: public void testModifyAttributesOfBasicTypes() {
617: logger.debug("Test: modify attributes of basic Java types (Integer, Boolean etc.).");
618: this.em = getEntityManager("ModifyBasicTypeAttributes", false);
619: persist(entityM);
620:
621: em.getTransaction().begin();
622: final OWLClassM m = em.find(OWLClassM.class, entityM.getKey());
623:• m.setBooleanAttribute(!entityM.getBooleanAttribute());
624: m.setDoubleAttribute(m.getDoubleAttribute() - 100.0);
625: m.setLongAttribute(m.getLongAttribute() + 100L);
626: m.setDateAttribute(new Date(System.currentTimeMillis() + 10000));
627: em.getTransaction().commit();
628:
629: final OWLClassM res = em.find(OWLClassM.class, entityM.getKey());
630: assertEquals(m.getBooleanAttribute(), res.getBooleanAttribute());
631: assertEquals(m.getLongAttribute(), res.getLongAttribute());
632: assertEquals(m.getDoubleAttribute(), res.getDoubleAttribute());
633: assertEquals(m.getDateAttribute(), res.getDateAttribute());
634: }
635:
636: @Test
637: public void testModifyEnumAttribute() {
638: logger.debug("Test: modify enum attribute.");
639: this.em = getEntityManager("ModifyEnumAttribute", false);
640: assertNotNull(entityM.getEnumAttribute());
641: persist(entityM);
642:
643: final OWLClassM.Severity updated = OWLClassM.Severity.LOW;
644: em.getTransaction().begin();
645: final OWLClassM m = em.find(OWLClassM.class, entityM.getKey());
646: m.setEnumAttribute(updated);
647: em.getTransaction().commit();
648:
649: final OWLClassM res = em.find(OWLClassM.class, entityM.getKey());
650: assertNotNull(res);
651: assertEquals(updated, res.getEnumAttribute());
652: }
653:
654: @Test
655: public void testCascadeOfNewlyPersistedOnMerge() {
656: logger.debug("Test: cascade merging of an object that has been just persisted.");
657: this.em = getEntityManager("CascadeMergeWithNewlyPersisted", true);
658: em.getTransaction().begin();
659: em.persist(entityO);
660: entityO.getOwlClassESet().forEach(em::persist);
661: em.getTransaction().commit();
662:
663: final OWLClassE newE = new OWLClassE();
664: newE.setStringAttribute("NewlyAddedE");
665: final OWLClassO toUpdate = em.find(OWLClassO.class, entityO.getUri());
666: em.detach(toUpdate);
667:
668: em.getTransaction().begin();
669: toUpdate.getOwlClassESet().add(newE);
670: em.persist(newE);
671: final OWLClassO merged = em.merge(toUpdate);
672: assertTrue(merged.getOwlClassESet().contains(newE));
673: em.getTransaction().commit();
674:
675: final OWLClassE resE = em.find(OWLClassE.class, newE.getUri());
676: assertNotNull(resE);
677: final OWLClassO resO = em.find(OWLClassO.class, entityO.getUri());
678: assertEquals(entityO.getOwlClassESet().size() + 1, resO.getOwlClassESet().size());
679: }
680:
681: @Test
682: public void modificationsOfCollectionAfterCascadeMergeAreWrittenOnCommit() {
683: logger.debug(
684: "Test: modify collection after cascade merge and check that the changes have been propagated on commit.");
685: this.em = getEntityManager("ModifyCollectionAfterCascadeMerge", true);
686: em.getTransaction().begin();
687: em.persist(entityJ);
688: em.getTransaction().commit();
689:
690: final OWLClassA newA = new OWLClassA(URI.create("http://krizik.felk.cvut.cz/ontologies/jopa/tests/newEntityA"));
691: em.getTransaction().begin();
692: final OWLClassJ merged = em.merge(entityJ);
693: merged.getOwlClassA().add(newA);
694: em.persist(newA);
695: em.getTransaction().commit();
696:
697: final OWLClassJ result = em.find(OWLClassJ.class, entityJ.getUri());
698: assertEquals(merged.getOwlClassA().size(), result.getOwlClassA().size());
699: boolean found = false;
700:• for (OWLClassA a : result.getOwlClassA()) {
701:• if (a.getUri().equals(newA.getUri())) {
702: found = true;
703: break;
704: }
705: }
706: assertTrue(found);
707: }
708:
709: @Test
710: public void testAddPropertiesWhenTheyWereNullOriginally() {
711: logger.debug("Test: add properties on update when the field was originally null.");
712: this.em = getEntityManager("AddPropertiesToNullOriginals", true);
713: em.getTransaction().begin();
714: assertNull(entityB.getProperties());
715: em.persist(entityB);
716: em.getTransaction().commit();
717:
718: final OWLClassB update = em.find(OWLClassB.class, entityB.getUri());
719: em.detach(update);
720: final Map<String, Set<String>> properties = Generators.createProperties(2);
721: update.setProperties(properties);
722: em.getTransaction().begin();
723: em.merge(update);
724: em.getTransaction().commit();
725:
726: final OWLClassB result = em.find(OWLClassB.class, entityB.getUri());
727: assertNotNull(result.getProperties());
728: assertEquals(properties, result.getProperties());
729: }
730:
731: @Test
732: public void testUpdatePlainLiteralObjectPropertyValueToAnotherIndividual() {
733: logger.debug("Test: update plain literal object property value to a different individual.");
734: this.em = getEntityManager("UpdatePlainLiteralObjectPropertyValue", true);
735: em.getTransaction().begin();
736: entityP.setIndividualUri(URI.create("http://krizik.felk.cvut.cz/ontologies/jopa#oldIndividual"));
737: em.persist(entityP);
738: em.getTransaction().commit();
739:
740: final OWLClassP update = em.find(OWLClassP.class, entityP.getUri());
741: final URI newValue = URI.create("http://krizik.felk.cvut.cz/ontologies/jopa#newIndividual");
742: em.getTransaction().begin();
743: update.setIndividualUri(newValue);
744: em.getTransaction().commit();
745:
746: final OWLClassP result = em.find(OWLClassP.class, entityP.getUri());
747: assertEquals(newValue, result.getIndividualUri());
748: }
749:
750: @Test
751: public void testUpdatePlainLiteralObjectPropertyValueToNull() {
752: logger.debug("Test: update plain literal object property value to null.");
753: this.em = getEntityManager("UpdatePlainLiteralObjectPropertyValueToNull", true);
754: em.getTransaction().begin();
755: entityP.setIndividualUri(URI.create("http://krizik.felk.cvut.cz/ontologies/jopa#SomeIndividual"));
756: em.persist(entityP);
757: em.getTransaction().commit();
758:
759: final OWLClassP update = em.find(OWLClassP.class, entityP.getUri());
760: assertNotNull(update.getIndividualUri());
761: em.getTransaction().begin();
762: update.setIndividualUri(null);
763: em.getTransaction().commit();
764:
765: final OWLClassP result = em.find(OWLClassP.class, entityP.getUri());
766: assertNull(result.getIndividualUri());
767: }
768:
769: @Test
770: public void testUpdatePluralPlainLiteralObjectPropertyAttribute() throws MalformedURLException {
771: logger.debug("Test: update plural plain literal object property attribute.");
772: this.em = getEntityManager("UpdatePluralPlainLiteralObjectPropertyValue", true);
773: entityP.setIndividuals(Generators.createUrls());
774: persist(entityP);
775:
776: final OWLClassP update = em.find(OWLClassP.class, entityP.getUri());
777: em.getTransaction().begin();
778: final URL added = new URL("http://krizik.felk.cvut.cz/ontologies/jopa#added");
779: final URL removed = entityP.getIndividuals().iterator().next();
780: update.getIndividuals().add(added);
781: update.getIndividuals().remove(removed);
782: em.getTransaction().commit();
783:
784: final OWLClassP res = em.find(OWLClassP.class, entityP.getUri());
785: assertNotNull(res);
786: assertEquals(update.getIndividuals(), res.getIndividuals());
787: }
788:
789: @Test
790: public void testUpdateSimpleListOfIdentifiersByAddingNewItems() {
791: this.em = getEntityManager("UpdateSimpleListOfIdentifiersByAddingItems", true);
792: entityP.setSimpleList(Generators.createListOfIdentifiers());
793: persist(entityP);
794:
795: final OWLClassP update = em.find(OWLClassP.class, entityP.getUri());
796: em.getTransaction().begin();
797:• for (int i = 0; i < Generators.randomPositiveInt(5, 10); i++) {
798: final URI u = URI.create("http://krizik.felk.cvut.cz/ontologies/jopa#Added-" + i);
799: // Insert at random position
800: update.getSimpleList().add(Generators.randomInt(update.getSimpleList().size()), u);
801: }
802: em.getTransaction().commit();
803:
804: final OWLClassP res = em.find(OWLClassP.class, entityP.getUri());
805: assertNotNull(res);
806: assertEquals(update.getSimpleList(), res.getSimpleList());
807: }
808:
809: @Test
810: public void testUpdateReferencedListByRemovingAndAddingItems() {
811: this.em = getEntityManager("UpdateReferencedListByRemovingAndAddingItems", true);
812: entityP.setReferencedList(Generators.createListOfIdentifiers());
813: persist(entityP);
814:
815: final OWLClassP update = em.find(OWLClassP.class, entityP.getUri());
816: em.getTransaction().begin();
817:• for (int i = 0; i < Generators.randomPositiveInt(5, 10); i++) {
818: final URI u = URI.create("http://krizik.felk.cvut.cz/ontologies/jopa#Added-" + i);
819: // We might even overwrite items set in previous iterations, but it does not matter. JOPA should handle it
820: update.getReferencedList().set(Generators.randomInt(update.getReferencedList().size()), u);
821: }
822: em.getTransaction().commit();
823:
824: final OWLClassP res = em.find(OWLClassP.class, entityP.getUri());
825: assertNotNull(res);
826: assertEquals(update.getReferencedList(), res.getReferencedList());
827: }
828:
829: @Test
830: public void testUpdateStringAnnotationPropertyValue() {
831: this.em = getEntityManager("UpdateStringAnnotationPropertyValue", true);
832: entityN.setAnnotationProperty("PropertyValue");
833: persist(entityN);
834:
835: final String newValue = "newValue";
836: final OWLClassN update = em.find(OWLClassN.class, entityN.getId());
837: assertNotNull(update);
838: em.getTransaction().begin();
839: update.setAnnotationProperty(newValue);
840: em.getTransaction().commit();
841:
842: final OWLClassN res = em.find(OWLClassN.class, entityN.getId());
843: assertEquals(newValue, res.getAnnotationProperty());
844: }
845:
846: @Test
847: public void testUpdateAnnotationPropertyWithUriValueToDifferentValue() {
848: this.em = getEntityManager("UpdateAnnotationPropertyWithUriValueToDifferentValue", true);
849: entityN.setAnnotationUri(URI.create("http://krizik.felk.cvut.cz/ontologies/jopa#value"));
850: persist(entityN);
851:
852: final OWLClassN update = em.find(OWLClassN.class, entityN.getId());
853: assertNotNull(update);
854: em.getTransaction().begin();
855: final URI newUri = URI.create("http://krizik.felk.cvut.cz/ontologies/jopa#newValue");
856: update.setAnnotationUri(newUri);
857: em.getTransaction().commit();
858:
859: final OWLClassN res = em.find(OWLClassN.class, entityN.getId());
860: assertEquals(newUri, res.getAnnotationUri());
861: }
862:
863: @Test
864: public void testUpdateUriTypes() {
865: this.em = getEntityManager("UpdateUriTypes", true);
866: entityP.setTypes(Generators.createUriTypes());
867: persist(entityP);
868:
869: em.getTransaction().begin();
870: final OWLClassP update = em.find(OWLClassP.class, entityP.getUri());
871: final Iterator<URI> it = update.getTypes().iterator();
872:• while (it.hasNext()) {
873: it.next();
874:• if (Generators.randomBoolean()) {
875: it.remove();
876: }
877: }
878: update.getTypes().addAll(Generators.createUriTypes());
879: em.getTransaction().commit();
880:
881: final OWLClassP result = em.find(OWLClassP.class, entityP.getUri());
882: assertEquals(update.getTypes().size(), result.getTypes().size());
883: assertTrue(update.getTypes().containsAll(result.getTypes()));
884: }
885:
886: @Test
887: public void updateWithInvalidInstanceThrowsIntegrityConstraintsViolation() {
888: thrown.expect(RollbackException.class);
889: thrown.expectCause(isA(IntegrityConstraintViolatedException.class));
890:
891: this.em = getEntityManager("UpdateWithInvalidInstanceThrowsICViolation", true);
892: persist(entityN);
893:
894: entityN.setStringAttribute(null);
895: em.getTransaction().begin();
896: em.merge(entityN);
897: em.getTransaction().commit();
898: }
899:
900: @Test
901: public void addingValuesToDatatypePropertyCollectionAddsThemIntoRepository() {
902: this.em = getEntityManager("addingValuesToDatatypePropertyCollectionAddsThemIntoRepository", false);
903: persist(entityM);
904:
905: IntStream.generate(Generators::randomInt).limit(7).forEach(entityM.getIntegerSet()::add);
906: em.getTransaction().begin();
907: em.merge(entityM);
908: em.getTransaction().commit();
909:
910: final OWLClassM result = em.find(OWLClassM.class, entityM.getKey());
911: assertEquals(entityM.getIntegerSet(), result.getIntegerSet());
912: }
913:
914: @Test
915: public void removingValuesFromDatatypePropertyCollectionRemovesThemFromRepository() {
916: this.em = getEntityManager("removingValuesFromDatatypePropertyCollectionRemovesThemFromRepository", false);
917: persist(entityM);
918:
919: final Iterator<Integer> it = entityM.getIntegerSet().iterator();
920:• while (it.hasNext()) {
921: it.next();
922:• if (Generators.randomBoolean()) {
923: it.remove();
924: }
925: }
926: // Make sure there is at least one element
927: entityM.getIntegerSet().add(Generators.randomInt());
928:
929: em.getTransaction().begin();
930: em.merge(entityM);
931: em.getTransaction().commit();
932:
933: final OWLClassM result = em.find(OWLClassM.class, entityM.getKey());
934: assertEquals(entityM.getIntegerSet(), result.getIntegerSet());
935: }
936:
937: @Test
938: public void mergeReplacesReferenceWithInstanceFromRepository() {
939: this.em = getEntityManager("mergeReplacesReferenceWithInstanceFromRepository", true);
940: persist(entityD, entityA);
941:
942: final String originalString = entityA.getStringAttribute();
943: entityA.setStringAttribute("updatedStringAttribute");
944: em.getTransaction().begin();
945: final OWLClassD merged = em.merge(entityD);
946: assertEquals(originalString, merged.getOwlClassA().getStringAttribute());
947: em.getTransaction().commit();
948:
949: final OWLClassA result = em.find(OWLClassA.class, entityA.getUri());
950: assertEquals(originalString, result.getStringAttribute());
951: }
952:
953: @Test
954: public void mergeMergesUpdatedDataPropertyFields() {
955: this.em = getEntityManager("mergeMergesUpdatedDataPropertyFields", true);
956: persist(entityA);
957: final Set<String> newTypes =
958: Generators.createUriTypes().stream().map(URI::toString).collect(Collectors.toSet());
959: entityA.setTypes(newTypes);
960: final String newStringAtt = "newStringAttribute";
961: entityA.setStringAttribute(newStringAtt);
962:
963: em.getTransaction().begin();
964: final OWLClassA merged = em.merge(entityA);
965: assertEquals(newStringAtt, merged.getStringAttribute());
966: assertTrue(TestEnvironmentUtils.typesEqual(newTypes, merged.getTypes()));
967: em.getTransaction().commit();
968:
969: final OWLClassA result = em.find(OWLClassA.class, entityA.getUri());
970: assertEquals(newStringAtt, result.getStringAttribute());
971: assertTrue(TestEnvironmentUtils.typesEqual(newTypes, result.getTypes()));
972: }
973:
974: @Test
975: public void mergeMergesUpdateToObjectPropertyField() {
976: this.em = getEntityManager("mergeMergesUpdateToObjectPropertyField", true);
977: persist(entityD, entityA, entityA2);
978:
979: em.getTransaction().begin();
980: entityD.setOwlClassA(entityA2);
981: final OWLClassD merged = em.merge(entityD);
982: assertEquals(entityA2.getUri(), merged.getOwlClassA().getUri());
983: em.getTransaction().commit();
984:
985: final OWLClassD dResult = em.find(OWLClassD.class, entityD.getUri());
986: assertEquals(entityA2.getUri(), dResult.getOwlClassA().getUri());
987: final OWLClassA aReference = em.find(OWLClassA.class, entityA2.getUri());
988: assertSame(dResult.getOwlClassA(), aReference);
989: assertNotNull(em.find(OWLClassA.class, entityA.getUri()));
990: }
991: }