![[Jenkins]](/jenkins/static/0947d4d3/images/svgs/logo.svg){kind=logo}
Package: UpdateOperationsRunner
UpdateOperationsRunner
| name | instruction | branch | complexity | line | method | ||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| UpdateOperationsRunner(Logger) |
|
|
|
|
|
||||||||||||||||||||
| initialize() |
|
|
|
|
|
||||||||||||||||||||
| lambda$0(OWLClassA) |
|
|
|
|
|
||||||||||||||||||||
| modificationsOfCollectionAfterCascadeMergeAreWrittenOnCommit() |
|
|
|
|
|
||||||||||||||||||||
| persistEntityWithList() |
|
|
|
|
|
||||||||||||||||||||
| testAddNewToProperties() |
|
|
|
|
|
||||||||||||||||||||
| testAddPropertyValue() |
|
|
|
|
|
||||||||||||||||||||
| testAddPropertyValueDetached() |
|
|
|
|
|
||||||||||||||||||||
| testAddToReferencedList() |
|
|
|
|
|
||||||||||||||||||||
| testAddToSimpleList() |
|
|
|
|
|
||||||||||||||||||||
| testCascadeOfNewlyPersistedOnMerge() |
|
|
|
|
|
||||||||||||||||||||
| testClearReferencedList() |
|
|
|
|
|
||||||||||||||||||||
| testClearSimpleList() |
|
|
|
|
|
||||||||||||||||||||
| testMergeDetachedCascade() |
|
|
|
|
|
||||||||||||||||||||
| testMergeDetachedWithChanges() |
|
|
|
|
|
||||||||||||||||||||
| testMergeDetachedWithObjectPropertyChange() |
|
|
|
|
|
||||||||||||||||||||
| testMergeSet() |
|
|
|
|
|
||||||||||||||||||||
| testModifyAttributesOfBasicTypes() |
|
|
|
|
|
||||||||||||||||||||
| testModifyEnumAttribute() |
|
|
|
|
|
||||||||||||||||||||
| testModifyInferredAttribute() |
|
|
|
|
|
||||||||||||||||||||
| testRemoveFromReferencedList() |
|
|
|
|
|
||||||||||||||||||||
| testRemoveFromSimpleList() |
|
|
|
|
|
||||||||||||||||||||
| testReplaceReferencedList() |
|
|
|
|
|
||||||||||||||||||||
| testReplaceSimpleList() |
|
|
|
|
|
||||||||||||||||||||
| testUpdateDataLeaveLazy() |
|
|
|
|
|
||||||||||||||||||||
| testUpdateDataPropertySetNull() |
|
|
|
|
|
||||||||||||||||||||
| testUpdateReference() |
|
|
|
|
|
||||||||||||||||||||
Coverage
1: /**
2: * Copyright (C) 2011 Czech Technical University in Prague
3: *
4: * This program is free software: you can redistribute it and/or modify it under
5: * the terms of the GNU General Public License as published by the Free Software
6: * Foundation, either version 3 of the License, or (at your option) any
7: * later version.
8: *
9: * This program is distributed in the hope that it will be useful, but WITHOUT
10: * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11: * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
12: * details. You should have received a copy of the GNU General Public License
13: * along with this program. If not, see <http://www.gnu.org/licenses/>.
14: */
15: package cz.cvut.kbss.jopa.test.runner;
16:
17: import cz.cvut.kbss.jopa.exceptions.OWLInferredAttributeModifiedException;
18: import cz.cvut.kbss.jopa.test.*;
19: import cz.cvut.kbss.jopa.test.environment.Generators;
20: import org.junit.Test;
21:
22: import java.lang.reflect.Field;
23: import java.net.URI;
24: import java.util.*;
25: import java.util.logging.Logger;
26:
27: import static org.junit.Assert.*;
28:
29: public abstract class UpdateOperationsRunner extends BaseRunner {
30:
31: private OWLClassA entityA2;
32: private OWLClassF entityF;
33: private OWLClassJ entityJ;
34: private OWLClassO entityO;
35:
36: public UpdateOperationsRunner(Logger logger) {
37: super(logger);
38: initialize();
39: }
40:
41: private void initialize() {
42: this.entityF = new OWLClassF();
43: entityF.setUri(URI.create("http://krizik.felk.cvut.cz/ontologies/jopa/tests/entityF"));
44: this.entityA2 = new OWLClassA();
45: entityA2.setUri(URI.create("http://krizik.felk.cvut.cz/ontologies/jopa/tests/entityA2"));
46: this.entityJ = new OWLClassJ();
47: entityJ.setUri(URI.create("http://krizik.felk.cvut.cz/ontologies/jopa/tests/entityJ"));
48: final Set<OWLClassA> set = new HashSet<>(2);
49: set.add(entityA);
50: set.add(entityA2);
51: entityJ.setOwlClassA(set);
52: this.entityO = new OWLClassO(URI.create("http://krizik.felk.cvut.cz/ontologies/jopa/tests/entityO"));
53: final Set<OWLClassE> es = new HashSet<>();
54:• for (int i = 0; i < 5; i++) {
55: final OWLClassE e = new OWLClassE();
56: e.setStringAttribute("StringAttributeNo" + i);
57: es.add(e);
58: }
59: entityO.setOwlClassESet(es);
60: }
61:
62: @Test
63: public void testUpdateDataLeaveLazy() throws Exception {
64: logger.config(
65: "Test: update data property. Leaves lazily loaded field empty and checks that after commit the field's value hasn't changed.");
66: this.em = getEntityManager("UpdateDataProperty", false);
67: entityB.setProperties(Generators.createProperties());
68: persist(entityB);
69:
70: em.getTransaction().begin();
71: final OWLClassB b = em.find(OWLClassB.class, entityB.getUri());
72: assertNotNull(b);
73: final Field propsField = OWLClassB.class.getDeclaredField("properties");
74: propsField.setAccessible(true);
75: assertNull(propsField.get(b));
76: final String newString = "NewString";
77: b.setStringAttribute(newString);
78: em.getTransaction().commit();
79:
80: final OWLClassB res = em.find(OWLClassB.class, entityB.getUri());
81: assertNotNull(res);
82: assertEquals(newString, res.getStringAttribute());
83: assertNotNull(res.getProperties());
84: assertEquals(entityB.getProperties(), res.getProperties());
85: }
86:
87: @Test
88: public void testUpdateDataPropertySetNull() {
89: logger.config("Test: update data property. Set it to null.");
90: this.em = getEntityManager("UpdateDataPropertyToNull", true);
91: persist(entityA);
92:
93: em.getTransaction().begin();
94: final OWLClassA a = em.find(OWLClassA.class, entityA.getUri());
95: assertNotNull(a);
96: assertNotNull(a.getStringAttribute());
97: a.setStringAttribute(null);
98: em.getTransaction().commit();
99:
100: final OWLClassA res = em.find(OWLClassA.class, entityA.getUri());
101: assertNotNull(res);
102: assertNull(res.getStringAttribute());
103: assertEquals(entityA.getTypes(), res.getTypes());
104: }
105:
106: @Test
107: public void testUpdateReference() {
108: logger.config("Test: update reference to entity.");
109: this.em = getEntityManager("UpdateReference", true);
110: persist(entityD, entityI);
111: // em.persist(entityA, ctx);
112:
113: final OWLClassA newA = new OWLClassA();
114: newA.setUri(URI.create("http://krizik.felk.cvut.cz/ontologies/jopa/tests/newEntityA"));
115: newA.setStringAttribute("newA");
116: em.getTransaction().begin();
117: final OWLClassD d = em.find(OWLClassD.class, entityD.getUri());
118: assertNotNull(d.getOwlClassA());
119: d.setOwlClassA(newA);
120: final OWLClassI i = em.find(OWLClassI.class, entityI.getUri());
121: assertNotNull(i.getOwlClassA());
122: i.setOwlClassA(newA);
123: em.persist(newA);
124: em.getTransaction().commit();
125:
126: final OWLClassA resA1 = em.find(OWLClassA.class, newA.getUri());
127: assertNotNull(resA1);
128: final OWLClassD resD = em.find(OWLClassD.class, d.getUri());
129: assertEquals(resA1.getUri(), resD.getOwlClassA().getUri());
130: // assertSame(resD.getOwlClassA(), resA1);
131: assertNotNull(em.find(OWLClassA.class, entityA.getUri()));
132: final OWLClassI resI = em.find(OWLClassI.class, i.getUri());
133: assertEquals(newA.getUri(), resI.getOwlClassA().getUri());
134: assertNotNull(em.find(OWLClassA.class, entityA.getUri()));
135: assertEquals(resA1.getUri(), resI.getOwlClassA().getUri());
136: // assertEquals(resA1, resI.getOwlClassA());
137: }
138:
139: @Test
140: public void testMergeSet() throws Exception {
141: logger.config("Test: merge set property.");
142: this.em = getEntityManager("MergeSet", false);
143: persist(entityJ);
144: em.clear();
145:
146: entityJ.getOwlClassA().forEach(a -> a.setStringAttribute("NEWVALUE"));
147:
148: em.getTransaction().begin();
149: OWLClassJ merged = em.merge(entityJ);
150:
151:• for (final OWLClassA a : merged.getOwlClassA()) {
152: assertEquals(a.getStringAttribute(), "NEWVALUE");
153: }
154: em.getTransaction().commit();
155: }
156:
157: @Test
158: public void testMergeDetachedWithChanges() {
159: logger.config("Test: merge detached entity with changes.");
160: this.em = getEntityManager("UpdateDetached", true);
161: persist(entityA);
162:
163: final OWLClassA a = em.find(OWLClassA.class, entityA.getUri());
164: assertTrue(em.contains(a));
165: em.detach(a);
166: assertFalse(em.contains(a));
167: final String newType = "http://krizik.felk.cvut.cz/ontologies/jopa/entities#AddedType";
168: a.getTypes().add(newType);
169: em.getTransaction().begin();
170: final OWLClassA merged = em.merge(a);
171: assertTrue(merged.getTypes().contains(newType));
172: em.getTransaction().commit();
173:
174: final OWLClassA res = em.find(OWLClassA.class, a.getUri());
175: assertEquals(a.getTypes().size(), res.getTypes().size());
176: assertTrue(res.getTypes().containsAll(a.getTypes()));
177: }
178:
179: @Test
180: public void testMergeDetachedCascade() {
181: logger.config("Test: merge detached with cascade.");
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 = em.find(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 = em.find(OWLClassA.class, entityA.getUri());
201: assertNotNull(res);
202: assertEquals(newStr, res.getStringAttribute());
203: }
204:
205: @Test
206: public void testMergeDetachedWithObjectPropertyChange() {
207: logger.config("Test: merge detached with object property change.");
208: this.em = getEntityManager("UpdateDetachedWithOPChange", true);
209: persist(entityD, entityA);
210:
211: final OWLClassD d = em.find(OWLClassD.class, entityD.getUri());
212: em.detach(d);
213: d.setOwlClassA(entityA2);
214: em.getTransaction().begin();
215: em.merge(d);
216: em.persist(entityA2);
217: em.getTransaction().commit();
218:
219: final OWLClassD res = em.find(OWLClassD.class, entityD.getUri());
220: assertNotNull(res);
221: assertEquals(entityA2.getUri(), res.getOwlClassA().getUri());
222: assertEquals(entityA2.getStringAttribute(), res.getOwlClassA().getStringAttribute());
223: final OWLClassA resA = em.find(OWLClassA.class, entityA.getUri());
224: assertNotNull(resA);
225: assertEquals(entityA.getStringAttribute(), resA.getStringAttribute());
226: assertEquals(entityA.getTypes(), resA.getTypes());
227: }
228:
229: @Test
230: public void testRemoveFromSimpleList() {
231: logger.config("Test: remove entity from simple list. (But keep it in the ontology.)");
232: this.em = getEntityManager("UpdateRemoveFromSimpleList", true);
233: entityC.setSimpleList(Generators.createSimpleList());
234: persistEntityWithList();
235:
236: final OWLClassC c = em.find(OWLClassC.class, entityC.getUri());
237: assertNotNull(c);
238: em.getTransaction().begin();
239: final OWLClassA a = c.getSimpleList().get(1);
240: c.getSimpleList().remove(a);
241: em.getTransaction().commit();
242:
243: final OWLClassA resA = em.find(OWLClassA.class, a.getUri());
244: assertNotNull(resA);
245: final OWLClassC resC = em.find(OWLClassC.class, c.getUri());
246: assertEquals(c.getSimpleList().size(), resC.getSimpleList().size());
247: assertEquals(entityC.getSimpleList().size() - 1, resC.getSimpleList().size());
248:• for (OWLClassA aa : resC.getSimpleList()) {
249: assertFalse(resA.getUri().equals(aa.getUri()));
250: }
251: }
252:
253: private void persistEntityWithList() {
254: em.getTransaction().begin();
255: em.persist(entityC);
256:• if (entityC.getSimpleList() != null) {
257: entityC.getSimpleList().forEach(em::persist);
258: }
259:• if (entityC.getReferencedList() != null) {
260: entityC.getReferencedList().forEach(em::persist);
261: }
262: em.getTransaction().commit();
263: }
264:
265: @Test
266: public void testAddToSimpleList() {
267: logger.config("Test: add entity to simple list.");
268: this.em = getEntityManager("UpdateAddToSimpleList", true);
269: entityC.setSimpleList(Generators.createSimpleList());
270: em.getTransaction().begin();
271: em.persist(entityC);
272: entityC.getSimpleList().forEach(em::persist);
273: em.persist(entityA);
274: em.getTransaction().commit();
275:
276: em.getTransaction().begin();
277: final OWLClassC c = em.find(OWLClassC.class, entityC.getUri());
278: assertNotNull(c);
279: final OWLClassA a = em.find(OWLClassA.class, entityA.getUri());
280: assertNotNull(a);
281: assertFalse(c.getSimpleList().contains(a));
282: c.getSimpleList().add(a);
283: em.getTransaction().commit();
284:
285: final OWLClassC resC = em.find(OWLClassC.class, entityC.getUri());
286: assertEquals(c.getSimpleList().size(), resC.getSimpleList().size());
287: assertEquals(entityC.getSimpleList().size() + 1, resC.getSimpleList().size());
288: final OWLClassA resA = em.find(OWLClassA.class, entityA.getUri());
289: assertNotNull(resA);
290: assertTrue(resC.getSimpleList().contains(resA));
291: }
292:
293: @Test
294: public void testClearSimpleList() {
295: logger.config("Test: clear a simple list (but keep the entities in ontology).");
296: this.em = getEntityManager("UpdateClearSimpleList", true);
297: entityC.setSimpleList(Generators.createSimpleList());
298: persistEntityWithList();
299:
300: final OWLClassC c = em.find(OWLClassC.class, entityC.getUri());
301: assertNotNull(c);
302: assertFalse(c.getSimpleList().isEmpty());
303: em.getTransaction().begin();
304: c.getSimpleList().clear();
305: em.getTransaction().commit();
306:
307: final OWLClassC resC = em.find(OWLClassC.class, entityC.getUri());
308: assertNotNull(resC);
309:• assertTrue(resC.getSimpleList() == null || resC.getSimpleList().isEmpty());
310:• for (OWLClassA a : entityC.getSimpleList()) {
311: assertNotNull(em.find(OWLClassA.class, a.getUri()));
312: }
313: }
314:
315: @Test
316: public void testReplaceSimpleList() {
317: logger.config("Test: replace simple list with a new one.");
318: this.em = getEntityManager("UpdateReplaceSimpleList", true);
319: entityC.setSimpleList(Generators.createSimpleList());
320: persistEntityWithList();
321:
322: final OWLClassC c = em.find(OWLClassC.class, entityC.getUri());
323: final List<OWLClassA> newList = new ArrayList<>(1);
324: newList.add(entityA);
325: em.getTransaction().begin();
326: em.persist(entityA);
327: c.setSimpleList(newList);
328: em.getTransaction().commit();
329:
330: final OWLClassC resC = em.find(OWLClassC.class, entityC.getUri());
331: assertNotNull(resC);
332: assertEquals(newList.size(), resC.getSimpleList().size());
333: boolean found;
334:• for (OWLClassA a : newList) {
335: found = false;
336:• for (OWLClassA aa : resC.getSimpleList()) {
337:• if (a.getUri().equals(aa.getUri())) {
338: found = true;
339: break;
340: }
341: }
342: assertTrue(found);
343: }
344:• for (OWLClassA a : entityC.getSimpleList()) {
345: assertNotNull(em.find(OWLClassA.class, a.getUri()));
346: }
347: }
348:
349: @Test
350: public void testRemoveFromReferencedList() {
351: logger.config("Test: remove entity from referenced list. (But keep it in the ontology.");
352: this.em = getEntityManager("UpdateRemoveFromReferencedList", true);
353: entityC.setReferencedList(Generators.createReferencedList());
354: persistEntityWithList();
355:
356: final OWLClassC c = em.find(OWLClassC.class, entityC.getUri());
357: assertNotNull(c);
358: em.getTransaction().begin();
359: final OWLClassA a = c.getReferencedList().get(3);
360: c.getReferencedList().remove(a);
361: em.getTransaction().commit();
362:
363: final OWLClassA resA = em.find(OWLClassA.class, a.getUri());
364: assertNotNull(resA);
365: final OWLClassC resC = em.find(OWLClassC.class, c.getUri());
366: assertEquals(c.getReferencedList().size(), resC.getReferencedList().size());
367: assertEquals(entityC.getReferencedList().size() - 1, resC.getReferencedList().size());
368:• for (OWLClassA aa : resC.getReferencedList()) {
369: assertFalse(resA.getUri().equals(aa.getUri()));
370: }
371: }
372:
373: @Test
374: public void testAddToReferencedList() {
375: logger.config("Test: add entity to Referenced list.");
376: this.em = getEntityManager("UpdateAddToReferencedList", true);
377: entityC.setReferencedList(Generators.createReferencedList());
378: persistEntityWithList();
379:
380: em.getTransaction().begin();
381: final OWLClassC c = em.find(OWLClassC.class, entityC.getUri());
382: assertNotNull(c);
383: em.persist(entityA);
384: c.getReferencedList().add(entityA);
385: em.getTransaction().commit();
386:
387: final OWLClassC resC = em.find(OWLClassC.class, entityC.getUri());
388: assertEquals(c.getReferencedList().size(), resC.getReferencedList().size());
389: assertEquals(entityC.getReferencedList().size() + 1, resC.getReferencedList().size());
390: final OWLClassA resA = em.find(OWLClassA.class, entityA.getUri());
391: assertNotNull(resA);
392: assertTrue(resC.getReferencedList().contains(resA));
393: }
394:
395: @Test
396: public void testClearReferencedList() {
397: logger.config("Test: clear referenced list (but keep the entities in ontology).");
398: this.em = getEntityManager("UpdateClearReferencedList", true);
399: entityC.setReferencedList(Generators.createReferencedList());
400: persistEntityWithList();
401:
402: final OWLClassC c = em.find(OWLClassC.class, entityC.getUri());
403: assertNotNull(c);
404: assertFalse(c.getReferencedList().isEmpty());
405: em.getTransaction().begin();
406: c.setReferencedList(null);
407: em.getTransaction().commit();
408:
409: final OWLClassC resC = em.find(OWLClassC.class, entityC.getUri());
410: assertNotNull(resC);
411: assertNull(resC.getReferencedList());
412:• for (OWLClassA a : entityC.getReferencedList()) {
413: assertNotNull(em.find(OWLClassA.class, a.getUri()));
414: }
415: }
416:
417: @Test
418: public void testReplaceReferencedList() {
419: logger.config("Test: replace referenced list with a new one.");
420: this.em = getEntityManager("UpdateReplaceReferencedList", true);
421: entityC.setReferencedList(Generators.createReferencedList());
422: persistEntityWithList();
423:
424: final OWLClassC c = em.find(OWLClassC.class, entityC.getUri());
425: final List<OWLClassA> newList = new ArrayList<>(1);
426: newList.add(entityA);
427: em.getTransaction().begin();
428: em.persist(entityA);
429: c.setReferencedList(newList);
430: em.getTransaction().commit();
431:
432: final OWLClassC resC = em.find(OWLClassC.class, entityC.getUri());
433: assertNotNull(resC);
434: assertEquals(newList.size(), resC.getReferencedList().size());
435: boolean found;
436:• for (OWLClassA a : newList) {
437: found = false;
438:• for (OWLClassA aa : resC.getReferencedList()) {
439:• if (a.getUri().equals(aa.getUri())) {
440: found = true;
441: break;
442: }
443: }
444: assertTrue(found);
445: }
446:• for (OWLClassA a : entityC.getReferencedList()) {
447: assertNotNull(em.find(OWLClassA.class, a.getUri()));
448: }
449: }
450:
451: @Test
452: public void testAddNewToProperties() {
453: logger.config("Test: add a new property value to entity's properties.");
454: this.em = getEntityManager("UpdateAddNewToProperties", false);
455: entityB.setProperties(Generators.createProperties());
456: final Map<String, Set<String>> expected = new HashMap<>(entityB.getProperties().size() + 3);
457: expected.putAll(entityB.getProperties());
458: persist(entityB);
459: em.clear();
460:
461: final OWLClassB b = em.find(OWLClassB.class, entityB.getUri());
462: assertNotNull(b);
463: assertEquals(expected.size(), b.getProperties().size());
464: em.getTransaction().begin();
465: b.getProperties().put("http://krizik.felk.cvut.cz/ontologies/jopa/attributes#propertyFour",
466: Collections.singleton("http://krizik.felk.cvut.cz/ontologies/jopa/Stroustrup"));
467: expected.putAll(b.getProperties());
468: em.getTransaction().commit();
469:
470: final OWLClassB res = em.find(OWLClassB.class, b.getUri());
471: assertNotNull(res);
472: assertEquals(expected.size(), res.getProperties().size());
473:• for (Map.Entry<String, Set<String>> e : expected.entrySet()) {
474: assertTrue(res.getProperties().containsKey(e.getKey()));
475: final Set<String> s = e.getValue();
476: final Set<String> resS = res.getProperties().get(e.getKey());
477: assertEquals(s.size(), resS.size());
478: assertTrue(s.containsAll(resS));
479: }
480: }
481:
482: @Test
483: public void testAddPropertyValue() {
484: logger.config("Test: add another value to an existing property.");
485: this.em = getEntityManager("UpdateAddPropertyValue", false);
486: entityB.setProperties(Generators.createProperties());
487: final Map<String, Set<String>> expected = new HashMap<>(entityB.getProperties().size() + 3);
488: final String prop = entityB.getProperties().keySet().iterator().next();
489: expected.putAll(entityB.getProperties());
490: persist(entityB);
491: em.clear();
492:
493: final OWLClassB b = em.find(OWLClassB.class, entityB.getUri());
494: assertNotNull(b);
495: assertEquals(expected.size(), b.getProperties().size());
496: em.getTransaction().begin();
497: b.getProperties().get(prop).add("http://krizik.felk.cvut.cz/ontologies/jopa/Stroustrup");
498: expected.putAll(b.getProperties());
499: em.getTransaction().commit();
500:
501: final OWLClassB res = em.find(OWLClassB.class, b.getUri());
502: assertNotNull(res);
503: assertEquals(expected.size(), res.getProperties().size());
504:• for (Map.Entry<String, Set<String>> e : expected.entrySet()) {
505: assertTrue(res.getProperties().containsKey(e.getKey()));
506: final Set<String> s = e.getValue();
507: final Set<String> resS = res.getProperties().get(e.getKey());
508: assertEquals(s.size(), resS.size());
509:• if (e.getKey().equals(prop)) {
510:• assertTrue(s.size() > 1);
511:• for (String val : s) {
512: assertTrue(resS.contains(val));
513: }
514: } else {
515: assertTrue(resS.contains(s.iterator().next()));
516: }
517: }
518: }
519:
520: @Test
521: public void testAddPropertyValueDetached() {
522: logger.config("Test: add another value to an existing property.");
523: this.em = getEntityManager("UpdateAddPropertyValueDetached", false);
524: entityB.setProperties(Generators.createProperties());
525: final String prop = entityB.getProperties().keySet().iterator().next();
526: final String newPropertyValue = "http://krizik.felk.cvut.cz/ontologies/jopa#newPropertyValue";
527: persist(entityB);
528: em.clear();
529:
530: final OWLClassB b = em.find(OWLClassB.class, entityB.getUri());
531: b.getProperties().get(prop).add(newPropertyValue);
532: em.detach(b);
533: em.getTransaction().begin();
534: em.merge(b);
535: em.getTransaction().commit();
536:
537: final OWLClassB res = em.find(OWLClassB.class, entityB.getUri());
538: assertNotNull(res);
539: assertTrue(res.getProperties().get(prop).contains(newPropertyValue));
540: }
541:
542: @Test(expected = OWLInferredAttributeModifiedException.class)
543: public void testModifyInferredAttribute() {
544: logger.config("Test: modify an inferred attribute.");
545: this.em = getEntityManager("ModifyInferredAttribute", false);
546: persist(entityF);
547:
548: em.getTransaction().begin();
549: final OWLClassF f = em.find(OWLClassF.class, entityF.getUri());
550: assertNotNull(f);
551: f.setSecondStringAttribute("otherValue");
552: em.getTransaction().commit();
553: }
554:
555: @Test
556: public void testModifyAttributesOfBasicTypes() {
557: logger.config("Test: modify attributes of basic Java types (Integer, Boolean etc.).");
558: this.em = getEntityManager("ModifyBasicTypeAttributes", false);
559: persist(entityM);
560:
561: em.getTransaction().begin();
562: final OWLClassM m = em.find(OWLClassM.class, entityM.getKey());
563:• m.setBooleanAttribute(!entityM.getBooleanAttribute());
564: m.setDoubleAttribute(m.getDoubleAttribute() - 100.0);
565: m.setLongAttribute(m.getLongAttribute() + 100L);
566: m.setDateAttribute(new Date(System.currentTimeMillis() + 10000));
567: em.getTransaction().commit();
568:
569: final OWLClassM res = em.find(OWLClassM.class, entityM.getKey());
570: assertEquals(m.getBooleanAttribute(), res.getBooleanAttribute());
571: assertEquals(m.getLongAttribute(), res.getLongAttribute());
572: assertEquals(m.getDoubleAttribute(), res.getDoubleAttribute());
573: assertEquals(m.getDateAttribute(), res.getDateAttribute());
574: }
575:
576: @Test
577: public void testModifyEnumAttribute() {
578: logger.config("Test: modify enum attribute.");
579: this.em = getEntityManager("ModifyEnumAttribute", false);
580: assertNotNull(entityM.getEnumAttribute());
581: persist(entityM);
582:
583: final OWLClassM.Severity updated = OWLClassM.Severity.LOW;
584: em.getTransaction().begin();
585: final OWLClassM m = em.find(OWLClassM.class, entityM.getKey());
586: m.setEnumAttribute(updated);
587: em.getTransaction().commit();
588:
589: final OWLClassM res = em.find(OWLClassM.class, entityM.getKey());
590: assertNotNull(res);
591: assertEquals(updated, res.getEnumAttribute());
592: }
593:
594: @Test
595: public void testCascadeOfNewlyPersistedOnMerge() {
596: logger.config("Test: cascade merging of an object that has been just persisted.");
597: this.em = getEntityManager("CascadeMergeWithNewlyPersisted", true);
598: em.getTransaction().begin();
599: em.persist(entityO);
600: entityO.getOwlClassESet().forEach(em::persist);
601: em.getTransaction().commit();
602:
603: final OWLClassE newE = new OWLClassE();
604: newE.setStringAttribute("NewlyAddedE");
605: final OWLClassO toUpdate = em.find(OWLClassO.class, entityO.getUri());
606: em.detach(toUpdate);
607:
608: em.getTransaction().begin();
609: toUpdate.getOwlClassESet().add(newE);
610: em.persist(newE);
611: final OWLClassO merged = em.merge(toUpdate);
612: assertTrue(merged.getOwlClassESet().contains(newE));
613: em.getTransaction().commit();
614:
615: final OWLClassE resE = em.find(OWLClassE.class, newE.getUri());
616: assertNotNull(resE);
617: final OWLClassO resO = em.find(OWLClassO.class, entityO.getUri());
618: assertEquals(entityO.getOwlClassESet().size() + 1, resO.getOwlClassESet().size());
619: }
620:
621: @Test
622: public void modificationsOfCollectionAfterCascadeMergeAreWrittenOnCommit() {
623: logger.config(
624: "Test: modify collection after cascade merge and check that the changes have been propagated on commit.");
625: this.em = getEntityManager("ModifyCollectionAfterCascadeMerge", true);
626: em.getTransaction().begin();
627: em.persist(entityJ);
628: em.getTransaction().commit();
629:
630: final OWLClassA newA = new OWLClassA(URI.create("http://krizik.felk.cvut.cz/ontologies/jopa/tests/newEntityA"));
631: em.getTransaction().begin();
632: final OWLClassJ merged = em.merge(entityJ);
633: merged.getOwlClassA().add(newA);
634: em.persist(newA);
635: em.getTransaction().commit();
636:
637: final OWLClassJ result = em.find(OWLClassJ.class, entityJ.getUri());
638: assertEquals(merged.getOwlClassA().size(), result.getOwlClassA().size());
639: boolean found = false;
640:• for (OWLClassA a : result.getOwlClassA()) {
641:• if (a.getUri().equals(newA.getUri())) {
642: found = true;
643: break;
644: }
645: }
646: assertTrue(found);
647: }
648: }