Method: UpdateOperationsMultiContextRunner(Logger)

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.descriptors.Descriptor;
16: import cz.cvut.kbss.jopa.model.descriptors.EntityDescriptor;
17: import cz.cvut.kbss.jopa.model.descriptors.ObjectPropertyCollectionDescriptor;
18: import cz.cvut.kbss.jopa.test.*;
19: import cz.cvut.kbss.jopa.test.environment.Generators;
20: import cz.cvut.kbss.jopa.test.environment.TestEnvironmentUtils;
21: import org.junit.Test;
22: import org.slf4j.Logger;
23:
24: import java.net.URI;
25: import java.util.ArrayList;
26: import java.util.Collections;
27: import java.util.Iterator;
28: import java.util.List;
29:
30: import static org.junit.Assert.*;
31:
32: public abstract class UpdateOperationsMultiContextRunner extends BaseRunner {
33:
34: public UpdateOperationsMultiContextRunner(Logger logger) {
35: super(logger);
36: }
37:
38: @Test
39: public void testUpdateDataPropertyInContext() throws Exception {
40: logger.debug("Test: update data property value which is stored in a different context that the owner.");
41: this.em = getEntityManager("MultiUpdateDataPropertyInContext", false);
42: final Descriptor aDescriptor = new EntityDescriptor(CONTEXT_ONE);
43: aDescriptor.addAttributeContext(OWLClassA.class.getDeclaredField("stringAttribute"), CONTEXT_TWO);
44: em.getTransaction().begin();
45: em.persist(entityA, aDescriptor);
46: em.getTransaction().commit();
47:
48: em.getTransaction().begin();
49: final OWLClassA a = em.find(OWLClassA.class, entityA.getUri(), aDescriptor);
50: assertNotNull(a);
51: final String newAttValue = "newStringAttributeValue";
52: a.setStringAttribute(newAttValue);
53: em.getTransaction().commit();
54:
55: final OWLClassA resA = em.find(OWLClassA.class, entityA.getUri(), aDescriptor);
56: assertNotNull(resA);
57: assertEquals(newAttValue, resA.getStringAttribute());
58: assertEquals(entityA.getTypes(), resA.getTypes());
59: }
60:
61: @Test
62: public void testUpdateObjectPropertyToDifferentContext() throws Exception {
63: logger.debug("Test: update object property with value from different context than the previous.");
64: this.em = getEntityManager("MultiUpdateObjectPropertyToDifferent", false);
65: final Descriptor dDescriptor = new EntityDescriptor();
66: final Descriptor aDescriptor = new EntityDescriptor(CONTEXT_ONE);
67: dDescriptor.addAttributeDescriptor(OWLClassD.class.getDeclaredField("owlClassA"), aDescriptor);
68: em.getTransaction().begin();
69: em.persist(entityD, dDescriptor);
70: em.persist(entityA, aDescriptor);
71: em.getTransaction().commit();
72:
73: final OWLClassD d = em.find(OWLClassD.class, entityD.getUri(), dDescriptor);
74: assertNotNull(d);
75: assertNotNull(d.getOwlClassA());
76: em.getTransaction().begin();
77: final OWLClassA newA = new OWLClassA();
78: newA.setUri(URI.create("http://krizik.felk.cvut.cz/jopa/ontologies/newEntityA"));
79: newA.setStringAttribute("newAStringAttribute");
80: final Descriptor newADescriptor = new EntityDescriptor(CONTEXT_TWO);
81: em.persist(newA, newADescriptor);
82: dDescriptor.addAttributeDescriptor(OWLClassD.class.getDeclaredField("owlClassA"), newADescriptor);
83: d.setOwlClassA(newA);
84: em.getTransaction().commit();
85:
86: final OWLClassD resD = em.find(OWLClassD.class, entityD.getUri(), dDescriptor);
87: assertNotNull(resD);
88: assertEquals(newA.getUri(), resD.getOwlClassA().getUri());
89: assertEquals(newA.getStringAttribute(), resD.getOwlClassA().getStringAttribute());
90: final OWLClassA resA = em.find(OWLClassA.class, entityA.getUri(), aDescriptor);
91: assertNotNull(resA);
92: assertEquals(entityA.getStringAttribute(), resA.getStringAttribute());
93: }
94:
95: @Test
96: public void testUpdateAddToPropertiesInContext() throws Exception {
97: logger.debug("Test: add new property value, properties are stored in a different context.");
98: this.em = getEntityManager("MultiUpdateAddToPropertiesInContext", false);
99: entityB.setProperties(Generators.createProperties());
100: final Descriptor bDescriptor = new EntityDescriptor(CONTEXT_ONE);
101: bDescriptor.addAttributeContext(OWLClassB.class.getDeclaredField("properties"), CONTEXT_TWO);
102: em.getTransaction().begin();
103: em.persist(entityB, bDescriptor);
104: em.getTransaction().commit();
105:
106: em.getTransaction().begin();
107: final OWLClassB b = em.find(OWLClassB.class, entityB.getUri(), bDescriptor);
108: assertNotNull(b);
109: final String newKey = "http://krizik.felk.cvut.cz/jopa/ontologies/properties/newPropertyKey";
110: final String newValue = "http://krizik.felk.cvut.cz/jopa/ontologies/newPropertyValue";
111: final String newPropertyValue = "http://krizik.felk.cvut.cz/jopa/ontologies/NewValueOfAnOldProperty";
112: final String propertyToChange = b.getProperties().keySet().iterator().next();
113: b.getProperties().put(newKey, Collections.singleton(newValue));
114: b.getProperties().get(propertyToChange).add(newPropertyValue);
115: em.getTransaction().commit();
116:
117: final OWLClassB res = em.find(OWLClassB.class, entityB.getUri(), bDescriptor);
118: assertNotNull(res);
119: assertEquals(entityB.getStringAttribute(), res.getStringAttribute());
120: assertTrue(TestEnvironmentUtils.arePropertiesEqual(b.getProperties(), res.getProperties()));
121: }
122:
123: @Test
124: public void testUpdateAddToSimpleListInContext() throws Exception {
125: logger.debug("Test: add new element into a simple list stored in different context than its owner.");
126: this.em = getEntityManager("MultiUpdateAddToSimpleListInContext", false);
127: entityC.setSimpleList(Generators.createSimpleList(15));
128: final Descriptor cDescriptor = new EntityDescriptor(CONTEXT_ONE);
129: final Descriptor lstDescriptor = new ObjectPropertyCollectionDescriptor(CONTEXT_TWO,
130: OWLClassC.getSimpleListField());
131: cDescriptor.addAttributeDescriptor(OWLClassC.getSimpleListField(), lstDescriptor);
132: em.getTransaction().begin();
133: em.persist(entityC, cDescriptor);
134: entityC.getSimpleList().forEach(a -> em.persist(a, lstDescriptor));
135: em.getTransaction().commit();
136:
137: em.getTransaction().begin();
138: final OWLClassC c = em.find(OWLClassC.class, entityC.getUri(), cDescriptor);
139: assertNotNull(c);
140: assertEquals(entityC.getSimpleList().size(), c.getSimpleList().size());
141: c.getSimpleList().add(entityA);
142: em.persist(entityA, lstDescriptor);
143: em.getTransaction().commit();
144:
145: final OWLClassC resC = em.find(OWLClassC.class, entityC.getUri(), cDescriptor);
146: assertNotNull(resC);
147: assertEquals(entityC.getSimpleList().size() + 1, resC.getSimpleList().size());
148: boolean found = false;
149: for (OWLClassA a : resC.getSimpleList()) {
150: if (a.getUri().equals(entityA.getUri())) {
151: assertEquals(entityA.getStringAttribute(), a.getStringAttribute());
152: assertEquals(entityA.getTypes(), a.getTypes());
153: found = true;
154: break;
155: }
156: }
157: assertTrue(found);
158: }
159:
160: @Test
161: public void testUpdateAddToReferencedListInContext() throws Exception {
162: logger.debug("Test: add new element into a referenced list stored in different context than its owner.");
163: this.em = getEntityManager("MultiUpdateAddToReferencedListInContext", false);
164: entityC.setReferencedList(Generators.createReferencedList(10));
165: final Descriptor cDescriptor = new EntityDescriptor(CONTEXT_ONE);
166: final Descriptor lstDescriptor = new ObjectPropertyCollectionDescriptor(CONTEXT_TWO,
167: OWLClassC.getReferencedListField());
168: cDescriptor.addAttributeDescriptor(OWLClassC.getReferencedListField(), lstDescriptor);
169: em.getTransaction().begin();
170: em.persist(entityC, cDescriptor);
171: entityC.getReferencedList().forEach(a -> em.persist(a, lstDescriptor));
172: em.getTransaction().commit();
173:
174: em.getTransaction().begin();
175: final OWLClassC c = em.find(OWLClassC.class, entityC.getUri(), cDescriptor);
176: assertNotNull(c);
177: assertEquals(entityC.getReferencedList().size(), c.getReferencedList().size());
178: c.getReferencedList().add(entityA);
179: em.persist(entityA, lstDescriptor);
180: em.getTransaction().commit();
181:
182: final OWLClassC resC = em.find(OWLClassC.class, entityC.getUri(), cDescriptor);
183: assertNotNull(resC);
184: assertEquals(entityC.getReferencedList().size() + 1, resC.getReferencedList().size());
185: boolean found = false;
186: for (OWLClassA a : resC.getReferencedList()) {
187: if (a.getUri().equals(entityA.getUri())) {
188: assertEquals(entityA.getStringAttribute(), a.getStringAttribute());
189: assertEquals(entityA.getTypes(), a.getTypes());
190: found = true;
191: break;
192: }
193: }
194: assertTrue(found);
195: }
196:
197: @Test
198: public void testUpdateRemoveFromSimpleListInContext() throws Exception {
199: logger.debug("Test: remove element from simple list stored in a different context than its owner.");
200: this.em = getEntityManager("MultiUpdateRemoveFromSimpleListInContext", false);
201: entityC.setSimpleList(Generators.createSimpleList(15));
202: final Descriptor cDescriptor = new EntityDescriptor(CONTEXT_ONE);
203: final Descriptor lstDescriptor = new ObjectPropertyCollectionDescriptor(CONTEXT_TWO,
204: OWLClassC.getSimpleListField());
205: cDescriptor.addAttributeDescriptor(OWLClassC.getSimpleListField(), lstDescriptor);
206: em.getTransaction().begin();
207: em.persist(entityC, cDescriptor);
208: entityC.getSimpleList().forEach(a -> em.persist(a, lstDescriptor));
209: em.getTransaction().commit();
210:
211: em.getTransaction().begin();
212: final OWLClassC c = em.find(OWLClassC.class, entityC.getUri(), cDescriptor);
213: assertNotNull(c);
214: assertEquals(entityC.getSimpleList().size(), c.getSimpleList().size());
215: final OWLClassA a = c.getSimpleList().get(0);
216: c.getSimpleList().remove(0);
217: em.remove(a);
218: em.getTransaction().commit();
219:
220: final OWLClassC resC = em.find(OWLClassC.class, entityC.getUri(), cDescriptor);
221: assertNotNull(resC);
222: assertEquals(entityC.getSimpleList().size() - 1, resC.getSimpleList().size());
223: assertNull(em.find(OWLClassA.class, a.getUri(), lstDescriptor));
224: }
225:
226: @Test
227: public void testUpdateRemoveFromReferencedListInContext() throws Exception {
228: logger.debug("Test: remove elements from referenced list stored in a different context than its owner.");
229: this.em = getEntityManager("MultiUpdateRemoveFromReferencedListInContext", false);
230: entityC.setReferencedList(Generators.createReferencedList(10));
231: final Descriptor cDescriptor = new EntityDescriptor(CONTEXT_ONE);
232: final Descriptor lstDescriptor = new ObjectPropertyCollectionDescriptor(CONTEXT_TWO,
233: OWLClassC.getReferencedListField());
234: cDescriptor.addAttributeDescriptor(OWLClassC.getReferencedListField(), lstDescriptor);
235: em.getTransaction().begin();
236: em.persist(entityC, cDescriptor);
237: entityC.getReferencedList().forEach(a -> em.persist(a, lstDescriptor));
238: em.getTransaction().commit();
239:
240: em.getTransaction().begin();
241: final OWLClassC c = em.find(OWLClassC.class, entityC.getUri(), cDescriptor);
242: assertNotNull(c);
243: assertEquals(entityC.getReferencedList().size(), c.getReferencedList().size());
244: final List<OWLClassA> removed = new ArrayList<>();
245: int i = 0;
246: final Iterator<OWLClassA> it = c.getReferencedList().iterator();
247: while (it.hasNext()) {
248: i++;
249: final OWLClassA a = it.next();
250: if (i % 2 == 1) {
251: continue;
252: }
253: removed.add(a);
254: it.remove();
255: }
256: em.getTransaction().commit();
257:
258: final OWLClassC resC = em.find(OWLClassC.class, entityC.getUri(), cDescriptor);
259: assertNotNull(resC);
260: assertEquals(entityC.getReferencedList().size() - removed.size(), resC.getReferencedList()
261: .size());
262: for (OWLClassA a : removed) {
263: final OWLClassA resA = em.find(OWLClassA.class, a.getUri(), lstDescriptor);
264: assertNotNull(resA);
265: }
266: }
267:
268: @Test
269: public void testUpdatePlainIdentifierObjectPropertyValueInContext() {
270: final Descriptor pDescriptor = new EntityDescriptor(CONTEXT_ONE);
271: entityP.setIndividualUri(URI.create("http://krizik.felk.cvut.cz/originalIndividual"));
272: this.em = getEntityManager("UpdatePlainIdentifierObjectPropertyValueInContext", true);
273: em.getTransaction().begin();
274: em.persist(entityP, pDescriptor);
275: em.getTransaction().commit();
276:
277: final OWLClassP toUpdate = em.find(OWLClassP.class, entityP.getUri());
278: em.detach(toUpdate);
279: final URI newUri = URI.create("http://krizik.felk.cvut.cz/newIndividual");
280: toUpdate.setIndividualUri(newUri);
281: em.getTransaction().begin();
282: em.merge(toUpdate);
283: em.getTransaction().commit();
284:
285: final OWLClassP res = em.find(OWLClassP.class, entityP.getUri());
286: assertNotNull(res);
287: assertEquals(newUri, res.getIndividualUri());
288: }
289:
290: @Test
291: public void testUpdateFieldInMappedSuperclassInContext() throws Exception {
292: final Descriptor qDescriptor = new EntityDescriptor(CONTEXT_ONE);
293: final Descriptor aDescriptor = new EntityDescriptor(CONTEXT_TWO);
294: qDescriptor.addAttributeDescriptor(OWLClassQ.getOWlClassAField(), aDescriptor);
295: this.em = getEntityManager("UpdateFieldInMappedSuperclassInContext", true);
296: em.getTransaction().begin();
297: em.persist(entityQ, qDescriptor);
298: em.persist(entityA, aDescriptor);
299: em.getTransaction().commit();
300:
301: entityQ.setStringAttribute("newStringAttribute");
302: entityQ.setParentString("newParentStringAttribute");
303: entityQ.setLabel("newLabel");
304: final OWLClassA newA = new OWLClassA(URI.create("http://krizik.felk.cvut.cz/ontologies/jopa/tests/entityA2"));
305: newA.setStringAttribute("newAString");
306: entityQ.setOwlClassA(newA);
307: em.getTransaction().begin();
308: em.merge(entityQ, qDescriptor);
309: em.persist(newA, aDescriptor);
310: em.getTransaction().commit();
311:
312: final OWLClassQ res = em.find(OWLClassQ.class, entityQ.getUri(), qDescriptor);
313: assertNotNull(res);
314: assertEquals(entityQ.getStringAttribute(), res.getStringAttribute());
315: assertEquals(entityQ.getParentString(), res.getParentString());
316: assertEquals(entityQ.getLabel(), res.getLabel());
317: assertNotNull(res.getOwlClassA());
318: assertEquals(newA.getUri(), res.getOwlClassA().getUri());
319: assertNotNull(em.find(OWLClassA.class, newA.getUri()));
320: assertNotNull(em.find(OWLClassA.class, entityA.getUri(), aDescriptor));
321: }
322: }