Method: testRemoveSimple()

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 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.model.annotations.Id;
16: import cz.cvut.kbss.jopa.model.annotations.OWLAnnotationProperty;
17: import cz.cvut.kbss.jopa.model.annotations.OWLDataProperty;
18: import cz.cvut.kbss.jopa.model.annotations.OWLObjectProperty;
19: import cz.cvut.kbss.jopa.test.*;
20: import cz.cvut.kbss.jopa.test.environment.Generators;
21: import cz.cvut.kbss.jopa.utils.EntityPropertiesUtils;
22: import org.junit.Ignore;
23: import org.junit.Test;
24: import org.slf4j.Logger;
25:
26: import java.lang.reflect.Field;
27: import java.net.URI;
28: import java.util.*;
29:
30: import static org.junit.Assert.*;
31:
32: public abstract class DeleteOperationsRunner extends BaseRunner {
33:
34: public DeleteOperationsRunner(Logger logger) {
35: super(logger);
36: }
37:
38: @Test
39: public void testRemoveSimple() {
40: this.em = getEntityManager("SimpleRemove", false);
41: persist(entityA);
42:
43: final OWLClassA a = em.find(OWLClassA.class, entityA.getUri());
44: assertNotNull(a);
45: em.getTransaction().begin();
46: em.remove(a);
47: em.getTransaction().commit();
48:
49: assertNull(em.find(OWLClassA.class, entityA.getUri()));
50: }
51:
52: // TODO First we need to resolve referential integrity
53: @Ignore
54: @Test
55: public void testRemoveReference() {
56: this.em = getEntityManager("RemoveReference", false);
57: persist(entityD, entityA);
58:
59: final OWLClassA a = em.find(OWLClassA.class, entityA.getUri());
60: assertNotNull(a);
61: em.getTransaction().begin();
62: em.remove(a);
63: em.getTransaction().commit();
64:
65: final OWLClassD res = em.find(OWLClassD.class, entityD.getUri());
66: assertNotNull(res);
67: assertNull(em.find(OWLClassA.class, entityA.getUri()));
68: }
69:
70: @Test
71: public void testRemoveCascade() {
72: this.em = getEntityManager("RemoveCascade", false);
73: em.getTransaction().begin();
74: em.persist(entityG);
75: assertTrue(em.contains(entityG));
76: assertTrue(em.contains(entityH));
77: assertTrue(em.contains(entityA));
78: em.getTransaction().commit();
79:
80: em.getTransaction().begin();
81: final OWLClassG g = em.find(OWLClassG.class, entityG.getUri());
82: final OWLClassH h = em.find(OWLClassH.class, entityH.getUri());
83: final OWLClassA a = em.find(OWLClassA.class, entityA.getUri());
84: assertNotNull(g);
85: assertNotNull(h);
86: assertNotNull(a);
87: assertTrue(em.contains(g));
88: assertTrue(em.contains(h));
89: assertTrue(em.contains(a));
90: assertNotNull(g);
91: em.remove(g);
92: assertFalse(em.contains(g));
93: assertFalse(em.contains(h));
94: assertFalse(em.contains(a));
95: em.getTransaction().commit();
96:
97: assertNull(em.find(OWLClassG.class, entityG.getUri()));
98: assertNull(em.find(OWLClassH.class, entityH.getUri()));
99: assertNull(em.find(OWLClassA.class, entityA.getUri()));
100: }
101:
102: @Test(expected = IllegalArgumentException.class)
103: public void testRemoveDetached() {
104: this.em = getEntityManager("RemoveDetached", false);
105: assertNull(entityE.getUri());
106: persist(entityE);
107: assertNotNull(entityE.getUri());
108:
109: em.getTransaction().begin();
110: final OWLClassE e = em.find(OWLClassE.class, entityE.getUri());
111: assertNotNull(e);
112: assertTrue(em.contains(e));
113: em.detach(e);
114: assertFalse(em.contains(e));
115: em.remove(e);
116: }
117:
118: @Test
119: public void testRemoveFromSimpleList() {
120: this.em = getEntityManager("RemoveFromSimpleList", false);
121: final int size = 5;
122: entityC.setSimpleList(Generators.createSimpleList(size));
123: em.getTransaction().begin();
124: em.persist(entityC);
125: entityC.getSimpleList().forEach(em::persist);
126: em.getTransaction().commit();
127:
128: final int randIndex = Generators.randomInt(size);
129: final OWLClassA a = em.find(OWLClassA.class, entityC.getSimpleList().get(randIndex).getUri());
130: assertNotNull(a);
131: final OWLClassC c = em.find(OWLClassC.class, entityC.getUri());
132: assertNotNull(c);
133: em.getTransaction().begin();
134: // We have to remove A from the simple list as well because otherwise we would break the chain in instances
135: assertTrue(c.getSimpleList().remove(a));
136: em.remove(a);
137: em.getTransaction().commit();
138:
139: final OWLClassA resA = em.find(OWLClassA.class, a.getUri());
140: assertNull(resA);
141: final OWLClassC resC = em.find(OWLClassC.class, entityC.getUri());
142: boolean found = false;
143: for (OWLClassA aa : resC.getSimpleList()) {
144: if (aa.getUri().equals(a.getUri())) {
145: found = true;
146: break;
147: }
148: }
149: assertFalse(found);
150: }
151:
152: @Test
153: public void testRemoveFromReferencedList() {
154: this.em = getEntityManager("RemoveFromReferencedList", false);
155: final int size = 10;
156: entityC.setReferencedList(Generators.createReferencedList(size));
157: em.getTransaction().begin();
158: em.persist(entityC);
159: entityC.getReferencedList().forEach(em::persist);
160: em.getTransaction().commit();
161:
162: final int randIndex = Generators.randomInt(size);
163: final OWLClassA a = em.find(OWLClassA.class, entityC.getReferencedList().get(randIndex).getUri());
164: assertNotNull(a);
165: final OWLClassC c = em.find(OWLClassC.class, entityC.getUri());
166: assertNotNull(c);
167: em.getTransaction().begin();
168: // We have to remove A from the referenced list as well because otherwise we would break the chain in instances
169: assertTrue(c.getReferencedList().remove(a));
170: em.remove(a);
171: em.getTransaction().commit();
172:
173: final OWLClassA resA = em.find(OWLClassA.class, a.getUri());
174: assertNull(resA);
175: final OWLClassC resC = em.find(OWLClassC.class, entityC.getUri());
176: boolean found = false;
177: for (OWLClassA aa : resC.getReferencedList()) {
178: if (aa.getUri().equals(a.getUri())) {
179: found = true;
180: break;
181: }
182: }
183: assertFalse(found);
184: }
185:
186: @Test
187: public void testRemoveListOwner() {
188: this.em = getEntityManager("RemoveListOwner", false);
189: entityC.setSimpleList(Generators.createSimpleList());
190: entityC.setReferencedList(Generators.createReferencedList());
191: em.getTransaction().begin();
192: em.persist(entityC);
193: entityC.getSimpleList().forEach(em::persist);
194: entityC.getReferencedList().forEach(em::persist);
195: em.getTransaction().commit();
196:
197: final OWLClassC c = em.find(OWLClassC.class, entityC.getUri());
198: assertNotNull(c);
199: em.getTransaction().begin();
200: em.remove(c);
201: em.getTransaction().commit();
202:
203: em.getEntityManagerFactory().getCache().evictAll();
204: for (OWLClassA a : entityC.getSimpleList()) {
205: assertNotNull(em.find(OWLClassA.class, a.getUri()));
206: }
207: for (OWLClassA a : entityC.getReferencedList()) {
208: assertNotNull(em.find(OWLClassA.class, a.getUri()));
209: }
210: }
211:
212: @Test
213: public void testRemoveNotYetCommitted() {
214: this.em = getEntityManager("RemoveNotYetCommitted", false);
215: em.getTransaction().begin();
216: em.persist(entityE);
217: assertTrue(em.contains(entityE));
218: em.remove(entityE);
219: assertFalse(em.contains(entityE));
220: em.getTransaction().commit();
221:
222: final OWLClassE res = em.find(OWLClassE.class, entityE.getUri());
223: assertNull(res);
224: }
225:
226: @Test
227: public void testRemoveMergedWithCascading() {
228: this.em = getEntityManager("CascadeMergeAndRemove", false);
229: em.getTransaction().begin();
230: em.persist(entityG);
231: assertTrue(em.contains(entityA));
232: assertTrue(em.contains(entityG));
233: assertTrue(em.contains(entityH));
234: em.getTransaction().commit();
235: em.clear();
236:
237: final OWLClassG toDetach = em.find(OWLClassG.class, entityG.getUri());
238: assertNotNull(toDetach);
239: em.detach(toDetach);
240: assertFalse(em.contains(toDetach));
241: assertFalse(em.contains(toDetach.getOwlClassH()));
242: assertFalse(em.contains(toDetach.getOwlClassH().getOwlClassA()));
243:
244: em.getTransaction().begin();
245: final OWLClassG toRemove = em.merge(toDetach);
246: em.remove(toRemove);
247: em.getTransaction().commit();
248:
249: assertNull(em.find(OWLClassG.class, entityG.getUri()));
250: assertNull(em.find(OWLClassH.class, entityH.getUri()));
251: assertNull(em.find(OWLClassA.class, entityA.getUri()));
252: }
253:
254: @Test
255: public void removeDeletesAllPropertyAssertionsMappedByEntity() throws Exception {
256: this.em = getEntityManager("RemoveDeletesAllMappedAttributes", false);
257: em.getTransaction().begin();
258: entityC.setSimpleList(Generators.createSimpleList(5));
259: em.persist(entityC);
260: entityC.getSimpleList().forEach(em::persist);
261: em.getTransaction().commit();
262:
263: final OWLClassC toRemove = em.find(OWLClassC.class, entityC.getUri());
264: em.getTransaction().begin();
265: em.remove(toRemove);
266: em.getTransaction().commit();
267:
268: final List<String> properties = resolveCProperties();
269: for (String prop : properties) {
270: assertFalse(
271: em.createNativeQuery("ASK WHERE { ?x ?p ?o .}", Boolean.class).setParameter("x", entityC.getUri())
272: .setParameter("p", URI.create(prop)).getSingleResult());
273: }
274: }
275:
276: private List<String> resolveCProperties() throws Exception {
277: final List<String> lst = new ArrayList<>();
278: for (Field f : OWLClassC.class.getDeclaredFields()) {
279: if (f.getAnnotation(Id.class) != null || EntityPropertiesUtils.isFieldTransient(f)) {
280: continue;
281: }
282: if (f.getAnnotation(OWLDataProperty.class) != null) {
283: lst.add(f.getAnnotation(OWLDataProperty.class).iri());
284: } else if (f.getAnnotation(OWLObjectProperty.class) != null) {
285: lst.add(f.getAnnotation(OWLObjectProperty.class).iri());
286: } else if (f.getAnnotation(OWLAnnotationProperty.class) != null) {
287: lst.add(f.getAnnotation(OWLAnnotationProperty.class).iri());
288: }
289: }
290: return lst;
291: }
292:
293: @Test
294: public void testRemoveUnmappedPropertyValue() {
295: entityB.setProperties(Generators.createProperties());
296: this.em = getEntityManager("RemoveUnmappedPropertyValue", false);
297: em.getTransaction().begin();
298: em.persist(entityB);
299: em.getTransaction().commit();
300:
301: final String property = entityB.getProperties().keySet().iterator().next();
302: final Set<String> values = entityB.getProperties().get(property);
303: assertTrue(values.size() > 0);
304: final String valueToRemove = values.iterator().next();
305: em.getTransaction().begin();
306: final OWLClassB toUpdate = em.find(OWLClassB.class, entityB.getUri());
307: assertNotNull(toUpdate.getProperties());
308: assertTrue(toUpdate.getProperties().containsKey(property));
309: assertTrue(toUpdate.getProperties().get(property).contains(valueToRemove));
310: toUpdate.getProperties().get(property).remove(valueToRemove);
311: em.getTransaction().commit();
312:
313: final OWLClassB result = em.find(OWLClassB.class, entityB.getUri());
314: assertNotNull(result.getProperties());
315: assertTrue(result.getProperties().containsKey(property));
316: assertEquals(values.size() - 1, result.getProperties().get(property).size());
317: assertFalse(result.getProperties().get(property).contains(valueToRemove));
318: }
319:
320: @Test
321: public void testRemoveAllValuesOfUnmappedProperty() {
322: entityB.setProperties(Generators.createProperties());
323: this.em = getEntityManager("RemoveAllValuesOfUnmappedProperty", false);
324: em.getTransaction().begin();
325: em.persist(entityB);
326: em.getTransaction().commit();
327:
328: final String property = entityB.getProperties().keySet().iterator().next();
329: em.getTransaction().begin();
330: final OWLClassB toUpdate = em.find(OWLClassB.class, entityB.getUri());
331: assertNotNull(toUpdate.getProperties());
332: assertTrue(toUpdate.getProperties().containsKey(property));
333: toUpdate.getProperties().remove(property);
334: em.getTransaction().commit();
335:
336: final OWLClassB result = em.find(OWLClassB.class, entityB.getUri());
337: assertNotNull(result.getProperties());
338: assertFalse(result.getProperties().containsKey(property));
339: }
340:
341: @Test
342: public void testRemoveTypedUnmappedPropertyValue() {
343: this.em = getEntityManager("RemoveUnmappedPropertyValueTyped", false);
344: entityP.setProperties(Generators.createTypedProperties(10));
345: persist(entityP);
346:
347: em.getTransaction().begin();
348: final OWLClassP toUpdate = em.find(OWLClassP.class, entityP.getUri());
349: for (Set<Object> set : toUpdate.getProperties().values()) {
350: final Iterator<Object> it = set.iterator();
351: while (it.hasNext()) {
352: it.next();
353: if (Generators.randomBoolean()) {
354: it.remove();
355: }
356: }
357: }
358: em.getTransaction().commit();
359:
360: final OWLClassP res = em.find(OWLClassP.class, entityP.getUri());
361: assertEquals(toUpdate.getProperties(), res.getProperties());
362: }
363:
364: @Test
365: public void testRemoveAllValuesOfTypedUnmappedProperty() {
366: this.em = getEntityManager("RemoveAllValuesOfUnmappedPropertyTyped", false);
367: entityP.setProperties(Generators.createTypedProperties(15));
368: persist(entityP);
369:
370: final OWLClassP toUpdate = em.find(OWLClassP.class, entityP.getUri());
371: em.detach(toUpdate);
372: // Copy the keys to prevent concurrent modification
373: final Set<URI> keys = new HashSet<>(toUpdate.getProperties().keySet());
374: keys.stream().filter(k -> Generators.randomBoolean())
375: .forEach(key -> toUpdate.getProperties().remove(key));
376: em.getTransaction().begin();
377: em.merge(toUpdate);
378: em.getTransaction().commit();
379:
380: final OWLClassP res = em.find(OWLClassP.class, entityP.getUri());
381: assertEquals(toUpdate.getProperties(), res.getProperties());
382: }
383:
384: @Test
385: public void testRemoveAllValuesOfPluralPlainIdentifierObjectProperty() {
386: this.em = getEntityManager("RemoveAllValuesOfPluralPlainIdentifierOP", false);
387: entityP.setIndividuals(Generators.createUrls());
388: persist(entityP);
389:
390: final OWLClassP toUpdate = em.find(OWLClassP.class, entityP.getUri());
391: em.getTransaction().begin();
392: toUpdate.getIndividuals().clear();
393: em.getTransaction().commit();
394:
395: final OWLClassP res = em.find(OWLClassP.class, entityP.getUri());
396: assertNull(res.getIndividuals());
397: }
398:
399: @Test
400: public void testSetAnnotationPropertyValueToNull() {
401: this.em = getEntityManager("SetAnnotationPropertyValueToNull", false);
402: entityN.setAnnotationProperty("annotationPropertyValue");
403: persist(entityN);
404:
405: final OWLClassN update = em.find(OWLClassN.class, entityN.getId());
406: assertNotNull(update.getAnnotationProperty());
407: em.getTransaction().begin();
408: update.setAnnotationProperty(null);
409: em.getTransaction().commit();
410:
411: final OWLClassN res = em.find(OWLClassN.class, entityN.getId());
412: assertNull(res.getAnnotationProperty());
413: }
414:
415: @Test
416: public void testSetAnnotationPropertyValueContainingUriToNull() {
417: this.em = getEntityManager("SetAnnotationPropertyValueContainingUriToNull", false);
418: entityN.setAnnotationUri(URI.create("http://krizik.felk.cvut.cz/ontologies/jopa#annotationPropertyValue"));
419: persist(entityN);
420:
421: final OWLClassN update = em.find(OWLClassN.class, entityN.getId());
422: assertNotNull(update.getAnnotationUri());
423: em.getTransaction().begin();
424: update.setAnnotationUri(null);
425: em.getTransaction().commit();
426:
427: final OWLClassN res = em.find(OWLClassN.class, entityN.getId());
428: assertNull(res.getAnnotationUri());
429: }
430:
431: @Test
432: public void testClearUriTypes() {
433: this.em = getEntityManager("ClearUriTypes", false);
434: entityP.setTypes(Generators.createUriTypes());
435: persist(entityP);
436:
437: em.getTransaction().begin();
438: final OWLClassP update = em.find(OWLClassP.class, entityP.getUri());
439: update.getTypes().clear();
440: em.getTransaction().commit();
441:
442: final OWLClassP result = em.find(OWLClassP.class, entityP.getUri());
443: assertNull(result.getTypes());
444: }
445:
446: @Test
447: public void testRemoveEntityWithMappedSuperclass() {
448: this.em = getEntityManager("RemoveEntityWithMappedSuperclass", false);
449: persist(entityQ, entityA);
450:
451: em.getTransaction().begin();
452: final OWLClassQ toRemove = em.find(OWLClassQ.class, entityQ.getUri());
453: assertNotNull(toRemove);
454: em.remove(toRemove);
455: em.getTransaction().commit();
456:
457: assertNull(em.find(OWLClassQ.class, entityQ.getUri()));
458: assertNotNull(em.find(OWLClassA.class, entityA.getUri()));
459: final boolean remains = em.createNativeQuery("ASK WHERE { ?instance ?y ?z . }", Boolean.class)
460: .setParameter("instance",
461: entityQ.getUri()).getSingleResult();
462: assertFalse(remains);
463: }
464:
465: @Test
466: public void testRemoveDetachedWithCascadedReferenceUsingMergeAndRemove() {
467: this.em = getEntityManager("RemoveDetachedEntityWithCascadedReferenceUsingMergeAndRemove", true);
468: persist(entityH);
469: assertNotNull(em.find(OWLClassH.class, entityH.getUri()));
470: assertNotNull(em.find(OWLClassA.class, entityA.getUri()));
471: final OWLClassH h = new OWLClassH();
472: h.setUri(entityH.getUri());
473: final OWLClassA a = new OWLClassA();
474: a.setUri(entityA.getUri());
475: a.setStringAttribute(entityA.getStringAttribute());
476: a.setTypes(new HashSet<>(entityA.getTypes()));
477: h.setOwlClassA(a);
478:
479: em.clear();
480: em.getTransaction().begin();
481: final OWLClassH toRemove = em.merge(h);
482: em.remove(toRemove);
483: em.getTransaction().commit();
484:
485: assertNull(em.find(OWLClassH.class, entityH.getUri()));
486: assertNull(em.find(OWLClassA.class, entityA.getUri()));
487: }
488: }