095262f32cf7d8c35b6621b921c0b7adb87761e7
[taxeditor.git] / eu.etaxonomy.taxeditor.test / src / test / java / eu / etaxonomy / cdm / api / cache / CdmClientCachingTest.java
1 // $Id$
2 /**
3 * Copyright (C) 2014 EDIT
4 * European Distributed Institute of Taxonomy
5 * http://www.e-taxonomy.eu
6 *
7 * The contents of this file are subject to the Mozilla Public License Version 1.1
8 * See LICENSE.TXT at the top of this package for the full license terms.
9 */
10 package eu.etaxonomy.cdm.api.cache;
11
12 import java.util.Arrays;
13 import java.util.Iterator;
14 import java.util.List;
15 import java.util.Map;
16 import java.util.Set;
17 import java.util.UUID;
18
19 import org.apache.log4j.Level;
20 import org.apache.log4j.Logger;
21 import org.junit.Assert;
22 import org.junit.Before;
23 import org.junit.BeforeClass;
24 import org.junit.Test;
25 import org.unitils.dbunit.annotation.DataSet;
26
27 import eu.etaxonomy.cdm.api.service.ICommonService;
28 import eu.etaxonomy.cdm.api.service.IPolytomousKeyNodeService;
29 import eu.etaxonomy.cdm.api.service.IPolytomousKeyService;
30 import eu.etaxonomy.cdm.api.service.ITaxonService;
31 import eu.etaxonomy.cdm.model.common.CdmBase;
32 import eu.etaxonomy.cdm.model.common.Language;
33 import eu.etaxonomy.cdm.model.common.LanguageString;
34 import eu.etaxonomy.cdm.model.description.KeyStatement;
35 import eu.etaxonomy.cdm.model.description.PolytomousKey;
36 import eu.etaxonomy.cdm.model.description.PolytomousKeyNode;
37 import eu.etaxonomy.taxeditor.httpinvoker.BaseRemotingTest;
38 import eu.etaxonomy.taxeditor.httpinvoker.CDMServer;
39 import eu.etaxonomy.taxeditor.remoting.cache.CdmTransientEntityCacher;
40 import eu.etaxonomy.taxeditor.session.ICdmEntitySession;
41 import eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled;
42 import eu.etaxonomy.taxeditor.session.MockSessionOwner;
43
44 /**
45 * @author cmathew
46 * @date 7 Oct 2014
47 *
48 */
49 @DataSet
50 public class CdmClientCachingTest extends BaseRemotingTest {
51
52 private static final Logger logger = Logger.getLogger(CdmClientCachingTest.class);
53
54 private final UUID polytomousKeyUuid = UUID.fromString("0d53ba20-7de4-4baa-bd8a-401048447d66");
55 private final UUID taxon1Uuid = UUID.fromString("2b336df7-29e8-4f79-985f-66502739d22f");
56 private final UUID polytomousKeyNodeUuid1 = UUID.fromString("75e4c924-ff58-4ee7-a59d-fd9173517d08");
57 private final UUID polytomousKeyNodeUuid2 = UUID.fromString("b775c027-13c0-4b87-8aa9-712faeaafbdc");
58
59
60 private final IPolytomousKeyService polytomousKeyService = getRemoteApplicationController().getPolytomousKeyService();
61 private final IPolytomousKeyNodeService polytomousKeyNodeService = getRemoteApplicationController().getPolytomousKeyNodeService();
62 private final ICommonService commonService = getRemoteApplicationController().getCommonService();
63 private final ITaxonService taxonService = getRemoteApplicationController().getTaxonService();
64
65
66 private CdmTransientEntityCacher cacher;
67 private ICdmEntitySession cdmEntitySession;
68
69 private static final List<String> PKEY_DEPTH1_INIT_STRATEGY = Arrays.asList(new String[] {
70 });
71
72 private static final List<String> PKEY_DEPTH2_INIT_STRATEGY = Arrays.asList(new String[] {
73 "root"});
74
75 private static final List<String> PKEY_DEPTH3_INIT_STRATEGY = Arrays.asList(new String[] {
76 "root.statement"});
77
78 private ICdmEntitySessionEnabled sessionOwner;
79
80 @BeforeClass
81 public static void initializePolytomousKeyTest() {
82 logger.setLevel(Level.INFO);
83 CDMServer.getInstance().setKeepServerRunning(true);
84 }
85
86 @Before
87 public void initializeSession() {
88 sessionOwner = new MockSessionOwner();
89 cdmEntitySession = cdmEntitySessionManager.newSession(sessionOwner, true);
90 cacher = getCacher(sessionOwner);
91 }
92
93
94
95 @Test
96 public void recursiveLoadSubGraphDepth1Test() {
97
98 // this call will load into the session cache the graph
99 // polytomous key
100 // |- root : polytomous key node
101 // in a recursive call
102 PolytomousKey pkey1 = CdmBase.deproxy(polytomousKeyService.load(polytomousKeyUuid, PKEY_DEPTH1_INIT_STRATEGY),PolytomousKey.class);
103
104
105 // checking to make sure the root object is in the session cache
106 Assert.assertSame(pkey1.getRoot(), cacher.getFromCache(pkey1.getRoot()));
107
108 }
109
110
111 @Test
112 public void recursiveLoadSubGraphDepth2Test() {
113
114 // this call will load into the session cache the graph
115 // polytomous key
116 // |- root : polytomous key node
117 // |- question : KeyStatement
118 // |- statement : KeyStatement
119 // in a recursive call
120 PolytomousKey pkey = CdmBase.deproxy(polytomousKeyService.load(polytomousKeyUuid, PKEY_DEPTH2_INIT_STRATEGY),PolytomousKey.class);
121 CdmTransientEntityCacher cacher = getCacher(sessionOwner);
122 // checking to make sure the root object is in the session cache
123 Assert.assertSame(pkey.getRoot(), cacher.getFromCache(pkey.getRoot()));
124 Assert.assertSame(pkey.getRoot().getStatement(), cacher.getFromCache(pkey.getRoot().getStatement()));
125 Assert.assertSame(pkey.getRoot().getQuestion(), cacher.getFromCache(pkey.getRoot().getQuestion()));
126
127 }
128
129 /**
130 * when : retrieving objects using recursive caching of object graphs with different depths
131 * then : the objects in the sub-graph having the same persistence id should be the same
132 */
133 @Test
134 public void lazyLoadRecursiveTest() {
135
136 // this call will load into the session cache the graph and update the objects in the sub-graph for a
137 // polytomous key
138 // |- root : polytomous key node
139 // |- question : KeyStatement
140 // |- statement : KeyStatement
141 PolytomousKey pkey1 = CdmBase.deproxy(polytomousKeyService.find(polytomousKeyUuid),PolytomousKey.class);
142
143 CdmTransientEntityCacher cacher = getCacher(sessionOwner);
144
145 }
146
147
148 /**
149 * when : retrieving objects using recursive caching of object graphs with different depths
150 * then : the objects in the sub-graph having the same persistence id should be the same
151 */
152 @Test
153 public void differentSubGraphDepthTest1() {
154
155 // this call will load into the session cache the graph and update the objects in the sub-graph for a
156 // polytomous key
157 // |- root : polytomous key node
158 // in a recursive call
159 PolytomousKey pkey1 = CdmBase.deproxy(polytomousKeyService.load(polytomousKeyUuid, PKEY_DEPTH1_INIT_STRATEGY),PolytomousKey.class);
160
161 CdmTransientEntityCacher cacher = getCacher(sessionOwner);
162
163 // this call will load into the session cache the graph and update the objects in the sub-graph for a
164 // polytomous key
165 // |- root : polytomous key node
166 // |- question : KeyStatement
167 // |- statement : KeyStatement
168 PolytomousKey pkey2 = CdmBase.deproxy(polytomousKeyService.load(polytomousKeyUuid, PKEY_DEPTH2_INIT_STRATEGY),PolytomousKey.class);
169
170
171 Assert.assertSame(pkey2.getRoot().getStatement(), cacher.getFromCache(pkey2.getRoot().getStatement()));
172 Assert.assertSame(pkey1.getRoot().getStatement(), pkey2.getRoot().getStatement());
173 Assert.assertSame(cacher.getFromCache(pkey1.getRoot().getStatement()), cacher.getFromCache(pkey2.getRoot().getStatement()));
174
175 }
176
177 /**
178 * when : retrieving objects using recursive caching of object graphs with different depths
179 * then : the objects in the sub-graph having the same persistence id should be the same
180 */
181 @Test
182 public void differentSubGraphDepthTest2() {
183
184 // this call will load into the session cache the graph and update the objects in the sub-graph for a
185 // polytomous key
186 // |- root : polytomous key node
187 // |- question : KeyStatement
188 // |- statement : KeyStatement
189 PolytomousKey pkey1 = CdmBase.deproxy(polytomousKeyService.load(polytomousKeyUuid, PKEY_DEPTH2_INIT_STRATEGY),PolytomousKey.class);
190
191 CdmTransientEntityCacher cacher = getCacher(sessionOwner);
192
193 // this call will load into the session cache the graph and update the objects in the sub-graph for a
194 // polytomous key
195 // |- root : polytomous key node
196 PolytomousKey pkey2 = CdmBase.deproxy(polytomousKeyService.load(polytomousKeyUuid, PKEY_DEPTH1_INIT_STRATEGY),PolytomousKey.class);
197
198
199 Assert.assertSame(pkey2.getRoot().getStatement(), cacher.getFromCache(pkey2.getRoot().getStatement()));
200 Assert.assertSame(pkey1.getRoot().getStatement(), pkey2.getRoot().getStatement());
201 Assert.assertSame(cacher.getFromCache(pkey1.getRoot().getStatement()), cacher.getFromCache(pkey2.getRoot().getStatement()));
202 }
203
204 /**
205 * when : retrieving objects using (first) recursive load directly and (second) lazy loading in the same session
206 * then : the objects in the sub-graph having the same persistence id should be the same
207 */
208 @Test
209 public void recursiveLoadAndLazyLoadTest() {
210
211 // this call will load into the session cache the graph and update the objects in the sub-graph for a
212 // polytomous key
213 // |- root : polytomous key node
214 // |- question : KeyStatement
215 // |- statement : KeyStatement
216 PolytomousKey pkey1 = CdmBase.deproxy(polytomousKeyService.load(polytomousKeyUuid, PKEY_DEPTH2_INIT_STRATEGY),PolytomousKey.class);
217
218 CdmTransientEntityCacher cacher = getCacher(sessionOwner);
219
220 // checking that the root is not null and
221 // that it exists in the cache and
222 // that both the original object and the
223 // cached object are the same
224 Assert.assertNotNull(pkey1.getRoot().getStatement());
225 Assert.assertNotNull(cacher.getFromCache(pkey1.getRoot().getStatement()));
226
227 // this call will load into the session cache the graph and update the objects in the sub-graph for a
228 // polytomous key
229 // |- root : polytomous key node
230 PolytomousKey pkey2 = CdmBase.deproxy(polytomousKeyService.find(polytomousKeyUuid),PolytomousKey.class);
231
232
233
234 Assert.assertSame(pkey2.getRoot().getStatement(), cacher.getFromCache(pkey2.getRoot().getStatement()));
235 Assert.assertSame(pkey1.getRoot().getStatement(), pkey2.getRoot().getStatement());
236 Assert.assertSame(cacher.getFromCache(pkey1.getRoot().getStatement()), cacher.getFromCache(pkey2.getRoot().getStatement()));
237 }
238
239 /**
240 * when : retrieving objects using (first) lazy loading and (second) recursive load directly in the same session
241 * then : the objects in the sub-graph having the same persistence id should be the same
242 */
243 @Test
244 public void lazyLoadAndRecursiveLoadTest() {
245
246
247 // this call will load into the session cache the graph and update the objects in the sub-graph for a
248 // polytomous key
249 // |- root : polytomous key node
250
251 PolytomousKey pkey1 = CdmBase.deproxy(polytomousKeyService.find(polytomousKeyUuid),PolytomousKey.class);
252
253
254 // lazy initialising root.statement
255 KeyStatement st = CdmBase.deproxy(pkey1.getRoot().getStatement(), KeyStatement.class);
256 st.getLabel();
257
258 // checking that the root is not null and
259 // that it exists in the cache and
260 // that both the original object and the
261 // cached object are the same
262 Assert.assertNotNull(pkey1.getRoot().getStatement());
263 Assert.assertSame(CdmBase.deproxy(pkey1.getRoot().getStatement(), KeyStatement.class),
264 cacher.getFromCache(pkey1.getRoot().getStatement(), KeyStatement.class));
265
266 // this call will load into the session cache the graph and update the objects in the sub-graph for a
267 // polytomous key
268 // |- root : polytomous key node
269 // |- question : KeyStatement
270 // |- statement : KeyStatement
271
272 PolytomousKey pkey2 = CdmBase.deproxy(polytomousKeyService.load(polytomousKeyUuid, PKEY_DEPTH2_INIT_STRATEGY),PolytomousKey.class);
273
274
275 Assert.assertSame(pkey2.getRoot().getStatement(), cacher.getFromCache(pkey2.getRoot().getStatement(), KeyStatement.class));
276 Assert.assertSame(st, pkey2.getRoot().getStatement());
277 Assert.assertSame(cacher.getFromCache(st), cacher.getFromCache(pkey2.getRoot().getStatement(), KeyStatement.class));
278 }
279
280
281
282
283
284 /**
285 * when : loading an object (first) and then (second) loading a graph the object is contained in, in the same session
286 * then : the object should be the same
287 */
288 @Test
289 public void subGraphObjectLoadTest1() {
290
291 // this call will load into the session cache a polytomous key node object
292 PolytomousKeyNode rootPKNode = CdmBase.deproxy(polytomousKeyNodeService.find(polytomousKeyNodeUuid1),PolytomousKeyNode.class);
293
294
295 Assert.assertNotNull(rootPKNode);
296 Assert.assertSame(rootPKNode, cacher.getFromCache(rootPKNode));
297
298 PolytomousKeyNode childOfRootPKNode = CdmBase.deproxy(polytomousKeyNodeService.find(polytomousKeyNodeUuid2),PolytomousKeyNode.class);
299
300
301 Assert.assertNotNull(childOfRootPKNode);
302 Assert.assertSame(childOfRootPKNode, cacher.getFromCache(childOfRootPKNode));
303
304 // this call will load into the session cache the graph and update the objects in the sub-graph for a
305 // polytomous key
306 // |- root : polytomous key node
307 // |- question : KeyStatement
308 // |- statement : KeyStatement
309
310 PolytomousKey pkey = CdmBase.deproxy(polytomousKeyService.load(polytomousKeyUuid, PKEY_DEPTH2_INIT_STRATEGY),PolytomousKey.class);
311
312
313 Assert.assertSame(childOfRootPKNode, cacher.getFromCache(childOfRootPKNode));
314 Assert.assertSame(pkey.getRoot().getChildAt(1), childOfRootPKNode);
315 }
316
317 /**
318 * when : loading a graph (first) and then (second) loading an object contained in in the graph, in the same session
319 * then : the object should be the same
320 */
321 @Test
322 public void subGraphObjectLoadTest2() {
323
324 // this call will load into the session cache the graph and update the objects in the sub-graph for a
325 // polytomous key
326 // |- root : polytomous key node
327 // |- question : KeyStatement
328 // |- statement : KeyStatement
329
330 PolytomousKey pkey = CdmBase.deproxy(polytomousKeyService.load(polytomousKeyUuid, PKEY_DEPTH2_INIT_STRATEGY),PolytomousKey.class);
331
332
333 // this call will load into the session cache a polytomous key node object
334 PolytomousKeyNode rootPKNode = CdmBase.deproxy(polytomousKeyNodeService.find(polytomousKeyNodeUuid1),PolytomousKeyNode.class);
335
336
337 Assert.assertNotNull(rootPKNode);
338 Assert.assertSame(rootPKNode, cacher.getFromCache(rootPKNode));
339
340 PolytomousKeyNode childOfRootPKNode = CdmBase.deproxy(polytomousKeyNodeService.find(polytomousKeyNodeUuid2),PolytomousKeyNode.class);
341
342
343 Assert.assertNotNull(childOfRootPKNode);
344 Assert.assertSame(childOfRootPKNode, cacher.getFromCache(childOfRootPKNode));
345
346 Assert.assertSame(childOfRootPKNode, cacher.getFromCache(childOfRootPKNode));
347 Assert.assertSame(pkey.getRoot().getChildAt(1), childOfRootPKNode);
348 }
349
350
351 /**
352 * when : loading objects from a collection
353 * then : the object stored in the cache should be the same
354 */
355 @Test
356 public void subGraphCollectionLoadTest() {
357
358 // this call will load into the session cache the graph and update the objects in the sub-graph for a
359 // polytomous key
360 // |- root : polytomous key node
361 // |- question : KeyStatement
362 // |- statement : KeyStatement
363
364 PolytomousKey pkey = CdmBase.deproxy(polytomousKeyService.load(polytomousKeyUuid, PKEY_DEPTH2_INIT_STRATEGY),PolytomousKey.class);
365
366
367 PolytomousKeyNode childOfRootPKNode = pkey.getRoot().getChildAt(1);
368
369 Assert.assertSame(childOfRootPKNode, cacher.getFromCache(childOfRootPKNode));
370 Assert.assertSame(pkey.getRoot().getChildAt(1), childOfRootPKNode);
371
372 }
373
374 /**
375 * when : loading a non-lazy collection in a subgraph and loading the collection directly
376 * then : the object stored in the cache should be the same as the object in the sub-graph collection and
377 * the object in the directly loaded collection
378 */
379 @Test
380 public void nonLazyCollectionLoadTest() {
381 // need to find an example of this
382 }
383
384 /**
385 * when : loading objects from a map
386 * then : the object stored in the cache should be the same
387 */
388 @Test
389 public void subGraphMapLoadTest() {
390
391 Language english = Language.getLanguageFromUuid(Language.uuidEnglish);
392 Language hindi = Language.getLanguageFromUuid(UUID.fromString("0a1d9d1d-135d-4575-b172-669b51673c39"));
393
394
395 // this call will load into the session cache the graph and update the objects in the sub-graph for a
396 // polytomous key
397 // |- root : polytomous key node
398 // |- question : KeyStatement
399 // |- statement : KeyStatement
400
401 PolytomousKey pkey = CdmBase.deproxy(polytomousKeyService.load(polytomousKeyUuid, PKEY_DEPTH3_INIT_STRATEGY),PolytomousKey.class);
402
403
404 Map<Language, LanguageString> labelMap = pkey.getRoot().getStatement().getLabel();
405 Set<Language> languages = labelMap.keySet();
406 Iterator<Language> languagesItr = languages.iterator();
407 while(languagesItr.hasNext()) {
408 Language lang = languagesItr.next();
409 if(lang.equals(english)) {
410 Assert.assertSame(lang, english);
411 }
412 if(lang.equals(hindi)) {
413 Assert.assertSame(lang, hindi);
414 }
415 Assert.assertSame(lang, cacher.getFromCache(lang));
416 }
417 }
418
419 /**
420 * when : loading a non-lazy map in a subgraph and loading the map directly
421 * then : the object stored in the cache should be the same as the object in the sub-graph map and
422 * the object in the directly loaded map
423 */
424 @Test
425 public void nonLazyMapLoadTest() {
426 // need to find an example of this
427 }
428
429
430
431 }