1 package de.dlr.shepard.context.references.basicreference.daos;
2
3 import static org.junit.jupiter.api.Assertions.assertEquals;
4 import static org.mockito.Mockito.doReturn;
5 import static org.mockito.Mockito.spy;
6 import static org.mockito.Mockito.verify;
7 import static org.mockito.Mockito.when;
8
9 import de.dlr.shepard.BaseTestCase;
10 import de.dlr.shepard.common.util.QueryParamHelper;
11 import de.dlr.shepard.context.collection.entities.DataObject;
12 import de.dlr.shepard.context.references.basicreference.endpoints.BasicReferenceAttributes;
13 import de.dlr.shepard.context.references.basicreference.entities.BasicReference;
14 import java.util.Collections;
15 import java.util.HashMap;
16 import java.util.List;
17 import java.util.Map;
18 import org.junit.jupiter.api.Test;
19 import org.mockito.InjectMocks;
20 import org.mockito.Mock;
21 import org.neo4j.ogm.session.Session;
22
23 public class BasicReferenceDAOTest extends BaseTestCase {
24
25 @Mock
26 private Session session;
27
28 @InjectMocks
29 private BasicReferenceDAO dao;
30
31 @Test
32 public void getEntityTypeTest() {
33 var type = dao.getEntityType();
34 assertEquals(BasicReference.class, type);
35 }
36
37 @Test
38 public void findByDataObjectTest_WithoutName() {
39 var obj = new DataObject(1L);
40 var obj2 = new DataObject(100L);
41 var ref = new BasicReference(2L);
42 var ref3 = new BasicReference(3L);
43 var ref4 = new BasicReference(4L);
44 ref.setDataObject(obj);
45 ref.setName("Yes");
46 ref4.setDataObject(obj2);
47 ref4.setName("Yes");
48 Map<String, Object> paramsMap = new HashMap<>();
49 paramsMap.put("name", null);
50
51 var query =
52 """
53 MATCH (d:DataObject)-[hr:has_reference]->(r:BasicReference { deleted: FALSE }) \
54 WHERE ID(d)=1 WITH r MATCH path=(r)-[*0..1]-(n) WHERE n.deleted = FALSE OR n.deleted IS NULL \
55 RETURN r, nodes(path), relationships(path)""";
56 when(session.query(BasicReference.class, query, paramsMap)).thenReturn(List.of(ref, ref3, ref4));
57
58 var params = new QueryParamHelper();
59 var actual = dao.findByDataObjectNeo4jId(1L, params);
60 verify(session).query(BasicReference.class, query, paramsMap);
61 assertEquals(List.of(ref), actual);
62 }
63
64 @Test
65 public void findByDataObjectWithShepardQueryParamsTest_WithoutName() {
66 var obj = new DataObject(1L);
67 obj.setShepardId(11L);
68 var obj2 = new DataObject(100L);
69 obj2.setShepardId(1001L);
70 var ref = new BasicReference(2L);
71 ref.setShepardId(21L);
72 var ref3 = new BasicReference(3L);
73 ref3.setShepardId(31L);
74 var ref4 = new BasicReference(4L);
75 ref4.setShepardId(41L);
76 ref.setDataObject(obj);
77 ref.setName("Yes");
78 ref4.setDataObject(obj2);
79 ref4.setName("Yes");
80 Map<String, Object> paramsMap = new HashMap<>();
81 paramsMap.put("name", null);
82
83 String query =
84 "MATCH (d:DataObject)-[hr:has_reference]->(br:BasicReference { deleted: FALSE }) WHERE d.shepardId=11 WITH br MATCH path=(br)-[*0..1]-(n) WHERE n.deleted = FALSE OR n.deleted IS NULL RETURN br, nodes(path), relationships(path)";
85 when(session.query(BasicReference.class, query, paramsMap)).thenReturn(List.of(ref, ref3, ref4));
86
87 var params = new QueryParamHelper();
88 var actual = dao.findByDataObjectShepardId(11L, params);
89 verify(session).query(BasicReference.class, query, paramsMap);
90 assertEquals(List.of(ref), actual);
91 }
92
93 @Test
94 public void findByDataObjectTest_WithName() {
95 var obj = new DataObject(1L);
96 var obj2 = new DataObject(100L);
97 var ref = new BasicReference(2L);
98 var ref3 = new BasicReference(3L);
99 var ref4 = new BasicReference(4L);
100 var ref5 = new BasicReference(5L);
101 ref.setDataObject(obj);
102 ref.setName("Yes");
103 ref4.setDataObject(obj2);
104 ref4.setName("Yes");
105 ref5.setDataObject(obj);
106 ref5.setName("No");
107 Map<String, Object> paramsMap = new HashMap<>();
108 paramsMap.put("name", "Yes");
109
110 var query =
111 """
112 MATCH (d:DataObject)-[hr:has_reference]->(r:BasicReference { name : $name, deleted: FALSE }) \
113 WHERE ID(d)=1 WITH r MATCH path=(r)-[*0..1]-(n) WHERE n.deleted = FALSE OR n.deleted IS NULL \
114 RETURN r, nodes(path), relationships(path)""";
115 when(session.query(BasicReference.class, query, paramsMap)).thenReturn(List.of(ref, ref3, ref4, ref5));
116
117 var params = new QueryParamHelper().withName("Yes");
118 var actual = dao.findByDataObjectNeo4jId(1L, params);
119 verify(session).query(BasicReference.class, query, paramsMap);
120 assertEquals(List.of(ref), actual);
121 }
122
123 @Test
124 public void findByDataObjectWithShepardQueryParamsTest_WithName() {
125 var obj = new DataObject(1L);
126 obj.setShepardId(11L);
127 var obj2 = new DataObject(100L);
128 obj2.setShepardId(1001L);
129 var ref = new BasicReference(2L);
130 ref.setShepardId(21L);
131 var ref3 = new BasicReference(3L);
132 ref3.setShepardId(31L);
133 var ref4 = new BasicReference(4L);
134 ref4.setShepardId(41L);
135 var ref5 = new BasicReference(5L);
136 ref5.setShepardId(51L);
137 ref.setDataObject(obj);
138 ref.setName("Yes");
139 ref4.setDataObject(obj2);
140 ref4.setName("Yes");
141 ref5.setDataObject(obj);
142 ref5.setName("No");
143 Map<String, Object> paramsMap = new HashMap<>();
144 paramsMap.put("name", "Yes");
145 String query =
146 "MATCH (d:DataObject)-[hr:has_reference]->(br:BasicReference { name : $name, deleted: FALSE }) WHERE d.shepardId=11 WITH br MATCH path=(br)-[*0..1]-(n) WHERE n.deleted = FALSE OR n.deleted IS NULL RETURN br, nodes(path), relationships(path)";
147
148 when(session.query(BasicReference.class, query, paramsMap)).thenReturn(List.of(ref, ref3, ref4, ref5));
149
150 var params = new QueryParamHelper().withName("Yes");
151 var actual = dao.findByDataObjectShepardId(11L, params);
152 assertEquals(List.of(ref), actual);
153 }
154
155 @Test
156 public void findByDataObjectTest_WithNameOrderByNameDesc() {
157 var obj = new DataObject(1L);
158 var obj2 = new DataObject(100L);
159 var ref = new BasicReference(2L);
160 var ref3 = new BasicReference(3L);
161 var ref4 = new BasicReference(4L);
162 var ref5 = new BasicReference(5L);
163 ref.setDataObject(obj);
164 ref.setName("Yes");
165 ref4.setDataObject(obj2);
166 ref4.setName("Yes");
167 ref5.setDataObject(obj);
168 ref5.setName("No");
169 Map<String, Object> paramsMap = new HashMap<>();
170 paramsMap.put("name", "Yes");
171
172 var query =
173 """
174 MATCH (d:DataObject)-[hr:has_reference]->(r:BasicReference { name : $name, deleted: FALSE }) \
175 WHERE ID(d)=1 WITH r ORDER BY toLower(r.name) DESC \
176 MATCH path=(r)-[*0..1]-(n) WHERE n.deleted = FALSE OR n.deleted IS NULL \
177 RETURN r, nodes(path), relationships(path)""";
178 when(session.query(BasicReference.class, query, paramsMap)).thenReturn(List.of(ref, ref3, ref4, ref5));
179
180 var params = new QueryParamHelper().withName("Yes");
181 var basicReferenceAttribute = BasicReferenceAttributes.name;
182 params = params.withOrderByAttribute(basicReferenceAttribute, true);
183 var actual = dao.findByDataObjectNeo4jId(1L, params);
184 verify(session).query(BasicReference.class, query, paramsMap);
185 assertEquals(List.of(ref), actual);
186 }
187
188 @Test
189 public void findByDataObjectWithShepardQueryParamsTest_WithNameOrderByNameDesc() {
190 var obj = new DataObject(1L);
191 obj.setShepardId(11L);
192 var obj2 = new DataObject(100L);
193 obj2.setShepardId(1001L);
194 var ref = new BasicReference(2L);
195 ref.setShepardId(21L);
196 var ref3 = new BasicReference(3L);
197 ref3.setShepardId(31L);
198 var ref4 = new BasicReference(4L);
199 ref4.setShepardId(41L);
200 var ref5 = new BasicReference(5L);
201 ref5.setShepardId(51L);
202 ref.setDataObject(obj);
203 ref.setName("Yes");
204 ref4.setDataObject(obj2);
205 ref4.setName("Yes");
206 ref5.setDataObject(obj);
207 ref5.setName("No");
208 Map<String, Object> paramsMap = new HashMap<>();
209 paramsMap.put("name", "Yes");
210 String query =
211 "MATCH (d:DataObject)-[hr:has_reference]->(br:BasicReference { name : $name, deleted: FALSE }) WHERE d.shepardId=11 WITH br ORDER BY toLower(br.name) DESC MATCH path=(br)-[*0..1]-(n) WHERE n.deleted = FALSE OR n.deleted IS NULL RETURN br, nodes(path), relationships(path)";
212 when(session.query(BasicReference.class, query, paramsMap)).thenReturn(List.of(ref, ref3, ref4, ref5));
213
214 var params = new QueryParamHelper().withName("Yes");
215 var basicReferenceAttribute = BasicReferenceAttributes.name;
216 params = params.withOrderByAttribute(basicReferenceAttribute, true);
217 var actual = dao.findByDataObjectShepardId(11L, params);
218 verify(session).query(BasicReference.class, query, paramsMap);
219 assertEquals(List.of(ref), actual);
220 }
221
222 @Test
223 public void findByDataObjectTest_WithPage() {
224 var obj = new DataObject(1L);
225 var obj2 = new DataObject(100L);
226 var ref = new BasicReference(2L);
227 var ref3 = new BasicReference(3L);
228 var ref4 = new BasicReference(4L);
229 ref.setDataObject(obj);
230 ref.setName("Yes");
231 ref4.setDataObject(obj2);
232 ref4.setName("Yes");
233 Map<String, Object> paramsMap = new HashMap<>();
234 paramsMap.put("offset", 300);
235 paramsMap.put("size", 100);
236 paramsMap.put("name", null);
237
238 var query =
239 """
240 MATCH (d:DataObject)-[hr:has_reference]->(r:BasicReference { deleted: FALSE }) \
241 WHERE ID(d)=1 WITH r SKIP $offset LIMIT $size \
242 MATCH path=(r)-[*0..1]-(n) WHERE n.deleted = FALSE OR n.deleted IS NULL \
243 RETURN r, nodes(path), relationships(path)""";
244 when(session.query(BasicReference.class, query, paramsMap)).thenReturn(List.of(ref, ref3, ref4));
245
246 var params = new QueryParamHelper().withPageAndSize(3, 100);
247 var actual = dao.findByDataObjectNeo4jId(1L, params);
248 verify(session).query(BasicReference.class, query, paramsMap);
249 assertEquals(List.of(ref), actual);
250 }
251
252 @Test
253 public void findByDataObjectWithShepardQueryParamsTest_WithPage() {
254 var obj = new DataObject(1L);
255 obj.setShepardId(11L);
256 var obj2 = new DataObject(100L);
257 obj2.setShepardId(1001L);
258 var ref = new BasicReference(2L);
259 ref.setShepardId(21L);
260 var ref3 = new BasicReference(3L);
261 ref3.setShepardId(31L);
262 var ref4 = new BasicReference(4L);
263 ref4.setShepardId(41L);
264 ref.setDataObject(obj);
265 ref.setName("Yes");
266 ref4.setDataObject(obj2);
267 ref4.setName("Yes");
268 Map<String, Object> paramsMap = new HashMap<>();
269 paramsMap.put("offset", 300);
270 paramsMap.put("size", 100);
271 paramsMap.put("name", null);
272 String query =
273 "MATCH (d:DataObject)-[hr:has_reference]->(br:BasicReference { deleted: FALSE }) WHERE d.shepardId=11 WITH br SKIP $offset LIMIT $size MATCH path=(br)-[*0..1]-(n) WHERE n.deleted = FALSE OR n.deleted IS NULL RETURN br, nodes(path), relationships(path)";
274 when(session.query(BasicReference.class, query, paramsMap)).thenReturn(List.of(ref, ref3, ref4));
275
276 var params = new QueryParamHelper().withPageAndSize(3, 100);
277 var actual = dao.findByDataObjectShepardId(11L, params);
278 verify(session).query(BasicReference.class, query, paramsMap);
279 assertEquals(List.of(ref), actual);
280 }
281
282 @Test
283 public void findByDataObjectTest_WithPageOrderByNameDesc() {
284 var obj = new DataObject(1L);
285 var obj2 = new DataObject(100L);
286 var ref = new BasicReference(2L);
287 var ref3 = new BasicReference(3L);
288 var ref4 = new BasicReference(4L);
289 ref.setDataObject(obj);
290 ref.setName("Yes");
291 ref4.setDataObject(obj2);
292 ref4.setName("Yes");
293 Map<String, Object> paramsMap = new HashMap<>();
294 paramsMap.put("offset", 300);
295 paramsMap.put("size", 100);
296 paramsMap.put("name", null);
297
298 var query =
299 """
300 MATCH (d:DataObject)-[hr:has_reference]->(r:BasicReference { deleted: FALSE }) \
301 WHERE ID(d)=1 WITH r ORDER BY toLower(r.name) DESC SKIP $offset LIMIT $size \
302 MATCH path=(r)-[*0..1]-(n) WHERE n.deleted = FALSE OR n.deleted IS NULL \
303 RETURN r, nodes(path), relationships(path)""";
304 when(session.query(BasicReference.class, query, paramsMap)).thenReturn(List.of(ref, ref3, ref4));
305
306 var params = new QueryParamHelper().withPageAndSize(3, 100);
307 var basicReferenceAttribute = BasicReferenceAttributes.name;
308 params = params.withOrderByAttribute(basicReferenceAttribute, true);
309 var actual = dao.findByDataObjectNeo4jId(1L, params);
310 verify(session).query(BasicReference.class, query, paramsMap);
311 assertEquals(List.of(ref), actual);
312 }
313
314 @Test
315 public void findByDataObjectWithShepardQueryParamsTest_WithPageOrderByNameDesc() {
316 var obj = new DataObject(1L);
317 obj.setShepardId(11L);
318 var obj2 = new DataObject(100L);
319 obj2.setShepardId(1001L);
320 var ref = new BasicReference(2L);
321 ref.setShepardId(21L);
322 var ref3 = new BasicReference(3L);
323 ref3.setShepardId(31L);
324 var ref4 = new BasicReference(4L);
325 ref4.setShepardId(41L);
326 ref.setDataObject(obj);
327 ref.setName("Yes");
328 ref4.setDataObject(obj2);
329 ref4.setName("Yes");
330 Map<String, Object> paramsMap = new HashMap<>();
331 paramsMap.put("offset", 300);
332 paramsMap.put("size", 100);
333 paramsMap.put("name", null);
334 String query =
335 "MATCH (d:DataObject)-[hr:has_reference]->(br:BasicReference { deleted: FALSE }) WHERE d.shepardId=11 WITH br ORDER BY toLower(br.name) DESC SKIP $offset LIMIT $size MATCH path=(br)-[*0..1]-(n) WHERE n.deleted = FALSE OR n.deleted IS NULL RETURN br, nodes(path), relationships(path)";
336 when(session.query(BasicReference.class, query, paramsMap)).thenReturn(List.of(ref, ref3, ref4));
337
338 var params = new QueryParamHelper().withPageAndSize(3, 100);
339 var basicReferenceAttribute = BasicReferenceAttributes.name;
340 params = params.withOrderByAttribute(basicReferenceAttribute, true);
341 var actual = dao.findByDataObjectShepardId(11L, params);
342 verify(session).query(BasicReference.class, query, paramsMap);
343 assertEquals(List.of(ref), actual);
344 }
345
346 @Test
347 public void findByDataObjectTest_WithNameAndPage() {
348 var obj = new DataObject(1L);
349 var obj2 = new DataObject(100L);
350 var ref = new BasicReference(2L);
351 var ref3 = new BasicReference(3L);
352 var ref4 = new BasicReference(4L);
353 var ref5 = new BasicReference(5L);
354 ref.setDataObject(obj);
355 ref.setName("Yes");
356 ref4.setDataObject(obj2);
357 ref4.setName("Yes");
358 ref5.setDataObject(obj);
359 ref5.setName("No");
360 Map<String, Object> paramsMap = new HashMap<>();
361 paramsMap.put("offset", 300);
362 paramsMap.put("size", 100);
363 paramsMap.put("name", "Yes");
364
365 var query =
366 """
367 MATCH (d:DataObject)-[hr:has_reference]->(r:BasicReference { name : $name, deleted: FALSE }) \
368 WHERE ID(d)=1 WITH r SKIP $offset LIMIT $size \
369 MATCH path=(r)-[*0..1]-(n) WHERE n.deleted = FALSE OR n.deleted IS NULL \
370 RETURN r, nodes(path), relationships(path)""";
371 when(session.query(BasicReference.class, query, paramsMap)).thenReturn(List.of(ref, ref3, ref4, ref5));
372
373 var params = new QueryParamHelper().withPageAndSize(3, 100).withName("Yes");
374 var actual = dao.findByDataObjectNeo4jId(1L, params);
375 verify(session).query(BasicReference.class, query, paramsMap);
376 assertEquals(List.of(ref), actual);
377 }
378
379 @Test
380 public void findByDataObjectWithShepardQueryParamsTest_WithNameAndPage() {
381 var obj = new DataObject(1L);
382 obj.setShepardId(11L);
383 var obj2 = new DataObject(100L);
384 obj2.setShepardId(1001L);
385 var ref = new BasicReference(2L);
386 ref.setShepardId(21L);
387 var ref3 = new BasicReference(3L);
388 ref3.setShepardId(31L);
389 var ref4 = new BasicReference(4L);
390 ref4.setShepardId(41L);
391 var ref5 = new BasicReference(5L);
392 ref5.setShepardId(51L);
393 ref.setDataObject(obj);
394 ref.setName("Yes");
395 ref4.setDataObject(obj2);
396 ref4.setName("Yes");
397 ref5.setDataObject(obj);
398 ref5.setName("No");
399 Map<String, Object> paramsMap = new HashMap<>();
400 paramsMap.put("offset", 300);
401 paramsMap.put("size", 100);
402 paramsMap.put("name", "Yes");
403 String query =
404 "MATCH (d:DataObject)-[hr:has_reference]->(br:BasicReference { name : $name, deleted: FALSE }) WHERE d.shepardId=11 WITH br SKIP $offset LIMIT $size MATCH path=(br)-[*0..1]-(n) WHERE n.deleted = FALSE OR n.deleted IS NULL RETURN br, nodes(path), relationships(path)";
405 when(session.query(BasicReference.class, query, paramsMap)).thenReturn(List.of(ref, ref3, ref4, ref5));
406
407 var params = new QueryParamHelper().withPageAndSize(3, 100).withName("Yes");
408 var actual = dao.findByDataObjectShepardId(11L, params);
409 verify(session).query(BasicReference.class, query, paramsMap);
410 assertEquals(List.of(ref), actual);
411 }
412
413 @Test
414 public void findByDataObjectWithShepardQueryParamsTest_WithNameAndPageOrderByNameDesc() {
415 var obj = new DataObject(1L);
416 obj.setShepardId(11L);
417 var obj2 = new DataObject(100L);
418 obj2.setShepardId(1001L);
419 var ref = new BasicReference(2L);
420 ref.setShepardId(21L);
421 var ref3 = new BasicReference(3L);
422 ref3.setShepardId(31L);
423 var ref4 = new BasicReference(4L);
424 ref4.setShepardId(41L);
425 var ref5 = new BasicReference(5L);
426 ref5.setShepardId(51L);
427 ref.setDataObject(obj);
428 ref.setName("Yes");
429 ref4.setDataObject(obj2);
430 ref4.setName("Yes");
431 ref5.setDataObject(obj);
432 ref5.setName("No");
433 Map<String, Object> paramsMap = new HashMap<>();
434 paramsMap.put("offset", 300);
435 paramsMap.put("size", 100);
436 paramsMap.put("name", "Yes");
437 String query =
438 "MATCH (d:DataObject)-[hr:has_reference]->(br:BasicReference { name : $name, deleted: FALSE }) WHERE d.shepardId=11 WITH br ORDER BY toLower(br.name) DESC SKIP $offset LIMIT $size MATCH path=(br)-[*0..1]-(n) WHERE n.deleted = FALSE OR n.deleted IS NULL RETURN br, nodes(path), relationships(path)";
439 when(session.query(BasicReference.class, query, paramsMap)).thenReturn(List.of(ref, ref3, ref4, ref5));
440
441 var params = new QueryParamHelper().withPageAndSize(3, 100).withName("Yes");
442 var basicReferenceAttribute = BasicReferenceAttributes.name;
443 params = params.withOrderByAttribute(basicReferenceAttribute, true);
444 var actual = dao.findByDataObjectShepardId(11L, params);
445 verify(session).query(BasicReference.class, query, paramsMap);
446 assertEquals(List.of(ref), actual);
447 }
448
449 @Test
450 public void findByDataObjectTest_WithNameAndPageOrderByNameDesc() {
451 var obj = new DataObject(1L);
452 var obj2 = new DataObject(100L);
453 var ref = new BasicReference(2L);
454 var ref3 = new BasicReference(3L);
455 var ref4 = new BasicReference(4L);
456 var ref5 = new BasicReference(5L);
457 ref.setDataObject(obj);
458 ref.setName("Yes");
459 ref4.setDataObject(obj2);
460 ref4.setName("Yes");
461 ref5.setDataObject(obj);
462 ref5.setName("No");
463 Map<String, Object> paramsMap = new HashMap<>();
464 paramsMap.put("offset", 300);
465 paramsMap.put("size", 100);
466 paramsMap.put("name", "Yes");
467
468 var query =
469 """
470 MATCH (d:DataObject)-[hr:has_reference]->(r:BasicReference { name : $name, deleted: FALSE }) \
471 WHERE ID(d)=1 WITH r ORDER BY toLower(r.name) DESC SKIP $offset LIMIT $size \
472 MATCH path=(r)-[*0..1]-(n) WHERE n.deleted = FALSE OR n.deleted IS NULL \
473 RETURN r, nodes(path), relationships(path)""";
474 when(session.query(BasicReference.class, query, paramsMap)).thenReturn(List.of(ref, ref3, ref4, ref5));
475
476 var params = new QueryParamHelper().withPageAndSize(3, 100).withName("Yes");
477 var basicReferenceAttribute = BasicReferenceAttributes.name;
478 params = params.withOrderByAttribute(basicReferenceAttribute, true);
479 var actual = dao.findByDataObjectNeo4jId(1L, params);
480 verify(session).query(BasicReference.class, query, paramsMap);
481 assertEquals(List.of(ref), actual);
482 }
483
484 @Test
485 public void getDataObjectsByQueryTest() {
486 BasicReferenceDAO spy = spy(BasicReferenceDAO.class);
487
488 var basicReference = new BasicReference(1L);
489
490 doReturn(List.of(basicReference)).when(spy).findByQuery("query", Collections.emptyMap());
491
492 var result = spy.getBasicReferencesByQuery("query");
493 assertEquals(List.of(basicReference), result);
494 }
495 }