1 package de.dlr.shepard.context.version.daos;
2
3 import static org.assertj.core.api.Assertions.assertThat;
4 import static org.junit.jupiter.api.Assertions.assertEquals;
5 import static org.mockito.Mockito.verify;
6 import static org.mockito.Mockito.when;
7
8 import de.dlr.shepard.BaseTestCase;
9 import de.dlr.shepard.common.configuration.feature.toggles.VersioningFeatureToggle;
10 import de.dlr.shepard.common.neo4j.daos.GenericDAO;
11 import de.dlr.shepard.common.util.CypherQueryHelper;
12 import de.dlr.shepard.common.util.CypherQueryHelper.Neighborhood;
13 import de.dlr.shepard.context.version.entities.Version;
14 import java.util.HashMap;
15 import java.util.List;
16 import java.util.Map;
17 import java.util.UUID;
18 import org.junit.jupiter.api.Test;
19 import org.junit.jupiter.api.condition.EnabledIf;
20 import org.mockito.InjectMocks;
21 import org.mockito.Mock;
22 import org.neo4j.ogm.model.QueryStatistics;
23 import org.neo4j.ogm.model.Result;
24 import org.neo4j.ogm.session.Session;
25
26 @EnabledIf(VersioningFeatureToggle.IS_ENABLED_METHOD_ID)
27 public class VersionDAOTest extends BaseTestCase {
28
29 @Mock
30 private Session session;
31
32 @Mock
33 private GenericDAO<?> genericDao;
34
35 @Mock
36 private Result result;
37
38 @Mock
39 private Result successorResult;
40
41 @Mock
42 private Result dataObjectResult;
43
44 @Mock
45 private Result createdByResult;
46
47 @Mock
48 private Result copyExternalDORResult;
49
50 @Mock
51 private Result copyFileReferencesResult;
52
53 @Mock
54 private Result copyFilePayloadResult;
55
56 @Mock
57 private Result copyTimeseriesReferencesResult;
58
59 @Mock
60 private Result copyCollectionReferencesResult;
61
62 @Mock
63 private Result copyCollectionPayloadResult;
64
65 @Mock
66 private Result copyURIReferencesResult;
67
68 @Mock
69 private Result copyURIPayloadResult;
70
71 @Mock
72 private Result copyTimeseriesPayloadResult;
73
74 @Mock
75 private Result copyStructuredDataReferencesResult;
76
77 @Mock
78 private Result copyStructuredDataPayloadResult;
79
80 @Mock
81 private Result copyInternalDORResult;
82
83 @Mock
84 private Result copyVersionAndCreatedByResult;
85
86 @Mock
87 private Result childResult;
88
89 @Mock
90 private QueryStatistics queryStatistics;
91
92 @InjectMocks
93 private VersionDAO dao;
94
95 @Test
96 public void getEntityTypeTest() {
97 var type = dao.getEntityType();
98 assertEquals(Version.class, type);
99 }
100
101 @Test
102 public void findByUUIDTest() {
103 Version ver = new Version();
104 ver.setDescription("version");
105 UUID id = new UUID(1L, 2L);
106 when(session.load(Version.class, id, 1)).thenReturn(ver);
107 Version found = dao.find(id);
108 assertEquals(ver, found);
109 }
110
111 @Test
112 public void findByCollectionIdVersionUIDTest() {
113 Version ver = new Version();
114 ver.setDescription("version");
115 UUID id = new UUID(1L, 2L);
116 ver.setUid(id);
117 when(session.load(Version.class, id, 1)).thenReturn(ver);
118 Version found = dao.find(id);
119 assertEquals(ver, found);
120 }
121
122 @Test
123 public void findAllVersionsTest() {
124 Version ver1 = new Version();
125 Version ver2 = new Version();
126 ver1.setName("name1");
127 ver2.setName("ver2");
128 long collectionId = 5;
129 String query = "";
130 query = query + "MATCH (col:Collection)-[]->(ver:Version) WHERE col.shepardId = " + collectionId + " ";
131 query = query + CypherQueryHelper.getReturnPart("ver", Neighborhood.EVERYTHING);
132 Map<String, Object> paramsMap = new HashMap<>();
133 when(session.query(Version.class, query, paramsMap)).thenReturn(List.of(ver1, ver2));
134 List<Version> allVersions = dao.findAllVersions(collectionId);
135 assertThat(allVersions.contains(ver1));
136 assertThat(allVersions.contains(ver2));
137 }
138
139 @Test
140 public void findHEADVersionTest() {
141 Version ver = new Version();
142 UUID uid = new UUID(1L, 2L);
143 ver.setUid(uid);
144 long collectionId = 5L;
145 Map<String, Object> paramsMap = new HashMap<>();
146 String query =
147 "MATCH (c:Collection)-[:has_version]->(v:Version) WHERE c.shepardId = " +
148 collectionId +
149 " AND " +
150 CypherQueryHelper.getVersionHeadPart("v") +
151 " " +
152 CypherQueryHelper.getReturnPart("v", Neighborhood.EVERYTHING);
153 when(session.query(Version.class, query, paramsMap)).thenReturn(List.of(ver));
154 Version headVersion = dao.findHEADVersion(collectionId);
155 assertEquals(ver, headVersion);
156 }
157
158 @Test
159 public void findVersionLigthByNeo4jIdTest() {
160 Version ver = new Version();
161 ver.setName("name");
162 long neo4jId = 10L;
163 String query = "MATCH (ve:VersionableEntity)-[:has_version]->(v) WHERE id(ve) = " + neo4jId + " RETURN v";
164 Map<String, Object> paramsMap = new HashMap<>();
165 when(session.query(Version.class, query, paramsMap)).thenReturn(List.of(ver));
166 Version found = dao.findVersionLightByNeo4jId(neo4jId);
167 assertEquals(ver, found);
168 }
169
170
171 public void createLinkTest() {
172 long versionableEntityId = 15L;
173 UUID versionUID = new UUID(3L, 4L);
174 String query =
175 "MATCH (ve:VersionableEntity), (v:Version) WHERE id(ve) = " +
176 versionableEntityId +
177 " AND v.uid = '" +
178 versionUID +
179 "' CREATE (ve)-[:has_version]->(v)";
180 Map<String, Object> paramsMap = new HashMap<>();
181 when(session.query(query, paramsMap)).thenReturn(result);
182 when(result.queryStatistics()).thenReturn(queryStatistics);
183 when(queryStatistics.containsUpdates()).thenReturn(true);
184 dao.createLink(versionableEntityId, versionUID);
185 verify(session).query(query, paramsMap);
186 }
187
188
189 public void copyDataObjectsWithParentsAndPredecessorsTest() {
190 UUID sourceVersionUID = new UUID(0L, 1L);
191 UUID targetVersionUID = new UUID(2L, 3L);
192 StringBuffer successorQueryBuffer = new StringBuffer();
193 successorQueryBuffer.append(
194 "MATCH (do_source_predecessor:DataObject)-[:has_successor]->(do_source_successor:DataObject)-[:has_version]->(v_source:Version)-[:has_predecessor]->(v_target:Version)<-[:has_version]-(do_target_predecessor:DataObject), "
195 );
196 successorQueryBuffer.append("(v_target)<-[:has_version]-(do_target_successor:DataObject) ");
197 successorQueryBuffer.append(
198 " WHERE v_source.uid = '" + sourceVersionUID + "' AND v_target.uid = '" + targetVersionUID + "' "
199 );
200 successorQueryBuffer.append(
201 " AND do_source_predecessor.shepardId=do_target_predecessor.shepardId AND do_source_successor.shepardId=do_target_successor.shepardId "
202 );
203 successorQueryBuffer.append(" CREATE (do_target_predecessor)-[:has_successor]->(do_target_successor)");
204 String successorsQuery = successorQueryBuffer.toString();
205 Map<String, Object> paramsMap = new HashMap<>();
206 when(session.query(successorsQuery, paramsMap)).thenReturn(successorResult);
207 when(successorResult.queryStatistics()).thenReturn(queryStatistics);
208 StringBuffer childQueryBuffer = new StringBuffer();
209 childQueryBuffer.append(
210 "MATCH (do_source_parent:DataObject)-[:has_child]->(do_source_child:DataObject)-[:has_version]->(v_source:Version)-[:has_predecessor]->(v_target:Version)<-[:has_version]-(do_target_parent:DataObject), "
211 );
212 childQueryBuffer.append("(v_target)<-[:has_version]-(do_target_child:DataObject) ");
213 childQueryBuffer.append(
214 " WHERE v_source.uid = '" + sourceVersionUID + "' AND v_target.uid = '" + targetVersionUID + "' "
215 );
216 childQueryBuffer.append(
217 " AND do_source_parent.shepardId=do_target_parent.shepardId AND do_source_child.shepardId=do_target_child.shepardId "
218 );
219 childQueryBuffer.append(" CREATE (do_target_parent)-[:has_child]->(do_target_child)");
220 String childQuery = childQueryBuffer.toString();
221 when(session.query(childQuery, paramsMap)).thenReturn(childResult);
222 when(childResult.queryStatistics()).thenReturn(queryStatistics);
223 StringBuffer dataObjectQueryBuffer = new StringBuffer();
224 dataObjectQueryBuffer.append(
225 "MATCH (do_source:DataObject)-[:has_version]->(v_source:Version)-[:has_predecessor]->(v_target:Version)<-[:has_version]-(col_target:Collection)"
226 );
227 dataObjectQueryBuffer.append(
228 " WHERE v_source.uid = '" + sourceVersionUID + "' AND v_target.uid = '" + targetVersionUID + "' "
229 );
230 dataObjectQueryBuffer.append(
231 " CREATE (col_target)-[:has_dataobject]->(do_target:DataObject:VersionableEntity:BasicEntity)-[:has_version]->(v_target) "
232 );
233 dataObjectQueryBuffer.append(" SET do_target = do_source");
234 String dataObjectQuery = dataObjectQueryBuffer.toString();
235 when(session.query(dataObjectQuery, paramsMap)).thenReturn(dataObjectResult);
236 when(dataObjectResult.queryStatistics()).thenReturn(queryStatistics);
237 when(queryStatistics.containsUpdates()).thenReturn(true);
238 StringBuffer createdByBuffer = new StringBuffer();
239 createdByBuffer.append(
240 "MATCH (u_creator:User)<-[:created_by]-(do_source:DataObject)-[:has_version]->(v_source:Version),(do_target:DataObject)-[:has_version]->(v_target:Version) "
241 );
242 createdByBuffer.append(
243 " WHERE v_source.uid = '" +
244 sourceVersionUID +
245 "' AND v_target.uid = '" +
246 targetVersionUID +
247 "' AND do_source.shepardId = do_target.shepardId "
248 );
249 createdByBuffer.append(" CREATE (do_target)-[:created_by]->(u_creator)");
250 String createdByQuery = createdByBuffer.toString();
251 when(session.query(createdByQuery, paramsMap)).thenReturn(createdByResult);
252 when(createdByResult.queryStatistics()).thenReturn(queryStatistics);
253 when(queryStatistics.containsUpdates()).thenReturn(true);
254
255 dao.copyDataObjectsWithParentsAndPredecessors(sourceVersionUID, targetVersionUID);
256 verify(session).query(dataObjectQuery, paramsMap);
257 verify(session).query(successorsQuery, paramsMap);
258 verify(session).query(childQuery, paramsMap);
259 }
260
261
262 public void testCopyDataObjectReferences() {
263 UUID sourceVersionUID = new UUID(0L, 1L);
264 UUID targetVersionUID = new UUID(2L, 3L);
265 Map<String, Object> paramsMap = new HashMap<>();
266 StringBuffer copyInternalDORBuffer = new StringBuffer();
267 copyInternalDORBuffer.append(
268 "MATCH (v_source:Version)<-[:has_version]-(c_pointer:Collection)-[:has_dataobject]->(do_source_pointer:DataObject)-[:has_reference]->(dor_source:DataObjectReference)-[:points_to]->(do_source_pointed_to:DataObject)<-[:has_dataobject]-(c_pointed_to:Collection), "
269 );
270 copyInternalDORBuffer.append(
271 "(do_target_pointed_to:DataObject)-[:has_version]->(v_target:Version)<-[:has_version]-(do_target_pointer:DataObject) "
272 );
273 copyInternalDORBuffer.append(
274 " WHERE v_source.uid = '" +
275 sourceVersionUID +
276 "' AND v_target.uid = '" +
277 targetVersionUID +
278 "' AND do_source_pointer.shepardId = do_target_pointer.shepardId AND do_source_pointed_to.shepardId = do_target_pointed_to.shepardId AND id(c_pointer) = id(c_pointed_to) "
279 );
280 copyInternalDORBuffer.append(
281 " CREATE (do_target_pointer)-[:has_reference]->(dor_target:DataObjectReference:BasicReference:VersionableEntity:BasicEntity)-[:points_to]->(do_target_pointed_to) "
282 );
283 copyInternalDORBuffer.append(" SET dor_target = dor_source");
284 String copyInternalDORString = copyInternalDORBuffer.toString();
285 when(session.query(copyInternalDORString, paramsMap)).thenReturn(copyInternalDORResult);
286 when(copyInternalDORResult.queryStatistics()).thenReturn(queryStatistics);
287 when(queryStatistics.containsUpdates()).thenReturn(true);
288 StringBuffer attachVersionAndCreatedByBuffer = new StringBuffer();
289 attachVersionAndCreatedByBuffer.append(
290 "MATCH (v_source:Version)<-[:has_version]-(dor_source:DataObjectReference)-[:created_by]->(u_creator:User), (v_target:Version)<-[:has_version]-(do_target_pointer:DataObject)-[:has_reference]->(dor_target:DataObjectReference) "
291 );
292 attachVersionAndCreatedByBuffer.append(
293 " WHERE v_source.uid = '" +
294 sourceVersionUID +
295 "' AND v_target.uid = '" +
296 targetVersionUID +
297 "' AND dor_source.shepardId = dor_target.shepardId "
298 );
299 attachVersionAndCreatedByBuffer.append(
300 " CREATE (v_target)<-[:has_version]-(dor_target)-[:created_by]->(u_creator)"
301 );
302 String attachVersionAndCreatedByString = attachVersionAndCreatedByBuffer.toString();
303 when(session.query(attachVersionAndCreatedByString, paramsMap)).thenReturn(copyVersionAndCreatedByResult);
304 when(copyVersionAndCreatedByResult.queryStatistics()).thenReturn(queryStatistics);
305 when(queryStatistics.containsUpdates()).thenReturn(true);
306 StringBuffer copyExternalDORBuffer = new StringBuffer();
307 copyExternalDORBuffer.append(
308 "MATCH (v_source_pointer:Version)<-[:has_version]-(c_pointer:Collection)-[:has_dataobject]->(do_source_pointer:DataObject)-[:has_reference]->(dor_source:DataObjectReference)-[:points_to]->(do_pointed_to:DataObject)<-[:has_dataobject]-(c_pointed_to:Collection)-[:has_version]->(v_source_pointed_to:Version), "
309 );
310 copyExternalDORBuffer.append("(dor_source:DataObjectReference)-[:created_by]->(u_creator:User), ");
311 copyExternalDORBuffer.append("(v_target_pointer:Version)<-[:has_version]-(do_target_pointer:DataObject) ");
312 copyExternalDORBuffer.append(
313 "WHERE v_source_pointer.uid = '" +
314 sourceVersionUID +
315 "' AND v_target_pointer.uid = '" +
316 targetVersionUID +
317 "' AND do_source_pointer.shepardId = do_target_pointer.shepardId AND NOT(c_pointer.shepardId = c_pointed_to.shepardId) "
318 );
319 copyExternalDORBuffer.append(
320 "CREATE (do_target_pointer)-[:has_reference]->(dor_target:DataObjectReference:BasicReference:VersionableEntity:BasicEntity)-[:points_to]->(do_pointed_to), "
321 );
322 copyExternalDORBuffer.append(" (v_target_pointer)<-[:has_version]-(dor_target)-[:created_by]->(u_creator) ");
323 copyExternalDORBuffer.append("SET dor_target=dor_source");
324 String copyExternalDORString = copyExternalDORBuffer.toString();
325 when(session.query(copyExternalDORString, paramsMap)).thenReturn(copyExternalDORResult);
326 when(copyExternalDORResult.queryStatistics()).thenReturn(queryStatistics);
327 when(queryStatistics.containsUpdates()).thenReturn(true);
328 dao.copyDataObjectReferences(sourceVersionUID, targetVersionUID);
329 verify(session).query(copyExternalDORString, paramsMap);
330 verify(session).query(copyInternalDORString, paramsMap);
331 verify(session).query(attachVersionAndCreatedByString, paramsMap);
332 }
333
334
335 public void copyFileReferencesTest() {
336 UUID sourceVersionUID = new UUID(0L, 1L);
337 UUID targetVersionUID = new UUID(2L, 3L);
338 Map<String, Object> paramsMap = new HashMap<>();
339 StringBuffer copyReferenceQueryBuffer = new StringBuffer();
340 copyReferenceQueryBuffer.append(
341 "MATCH (v_source:Version)<-[has_version]-(do_source:DataObject)-[:has_reference]->(fr_source:FileReference)-[:is_in_container]->(fc_pointed:FileContainer), "
342 );
343 copyReferenceQueryBuffer.append("(fr_source)-[:created_by]->(u_creator:User), ");
344 copyReferenceQueryBuffer.append("(v_target:Version)<-[:has_version]-(do_target:DataObject) ");
345 copyReferenceQueryBuffer.append(
346 "WHERE v_source.uid = '" +
347 sourceVersionUID +
348 "' AND v_target.uid = '" +
349 targetVersionUID +
350 "' AND do_source.shepardId = do_target.shepardId "
351 );
352 copyReferenceQueryBuffer.append(
353 "CREATE (v_target)<-[:has_version]-(fr_target:FileReference:BasicReference:VersionableEntity:BasicEntity)<-[:has_reference]-(do_target), "
354 );
355 copyReferenceQueryBuffer.append("(fc_pointed)<-[:is_in_container]-(fr_target)-[:created_by]->(u_creator) ");
356 copyReferenceQueryBuffer.append("SET fr_target = fr_source");
357 String copyReferenceQuery = copyReferenceQueryBuffer.toString();
358 when(session.query(copyReferenceQuery, paramsMap)).thenReturn(copyFileReferencesResult);
359 when(copyFileReferencesResult.queryStatistics()).thenReturn(queryStatistics);
360 StringBuffer copyPayloadQueryBuffer = new StringBuffer();
361 copyPayloadQueryBuffer.append(
362 "MATCH (v_source:Version)<-[:has_version]-(fr_source:FileReference)-[:has_payload]->(sf:ShepardFile), "
363 );
364 copyPayloadQueryBuffer.append("(v_target:Version)<-[:has_version]-(fr_target:FileReference) ");
365 copyPayloadQueryBuffer.append(
366 "WHERE v_source.uid = '" +
367 sourceVersionUID +
368 "' AND v_target.uid = '" +
369 targetVersionUID +
370 "' AND fr_source.shepardId = fr_target.shepardId "
371 );
372 copyPayloadQueryBuffer.append("CREATE (fr_target)-[:has_payload]->(sf)");
373 String copyPayloadQuery = copyPayloadQueryBuffer.toString();
374 when(session.query(copyPayloadQuery, paramsMap)).thenReturn(copyFilePayloadResult);
375 when(copyFilePayloadResult.queryStatistics()).thenReturn(queryStatistics);
376 when(queryStatistics.containsUpdates()).thenReturn(true);
377 dao.copyFileReferences(sourceVersionUID, targetVersionUID);
378 verify(session).query(copyReferenceQuery, paramsMap);
379 verify(session).query(copyPayloadQuery, paramsMap);
380 }
381
382
383 public void copyStructuredDataReferencesTest() {
384 UUID sourceVersionUID = new UUID(0L, 1L);
385 UUID targetVersionUID = new UUID(2L, 3L);
386 Map<String, Object> paramsMap = new HashMap<>();
387 StringBuffer copyReferenceQueryBuffer = new StringBuffer();
388 copyReferenceQueryBuffer.append(
389 "MATCH (v_source:Version)<-[has_version]-(do_source:DataObject)-[:has_reference]->(sdr_source:StructuredDataReference)-[:is_in_container]->(sdc_pointed:StructuredDataContainer), "
390 );
391 copyReferenceQueryBuffer.append("(sdr_source)-[:created_by]->(u_creator:User), ");
392 copyReferenceQueryBuffer.append("(v_target:Version)<-[:has_version]-(do_target:DataObject) ");
393 copyReferenceQueryBuffer.append(
394 "WHERE v_source.uid = '" +
395 sourceVersionUID +
396 "' AND v_target.uid = '" +
397 targetVersionUID +
398 "' AND do_source.shepardId = do_target.shepardId "
399 );
400 copyReferenceQueryBuffer.append(
401 "CREATE (v_target)<-[:has_version]-(sdr_target:StructuredDataReference:BasicReference:VersionableEntity:BasicEntity)<-[:has_reference]-(do_target), "
402 );
403 copyReferenceQueryBuffer.append("(sdc_pointed)<-[:is_in_container]-(sdr_target)-[:created_by]->(u_creator) ");
404 copyReferenceQueryBuffer.append("SET sdr_target = sdr_source");
405 String copyReferenceQuery = copyReferenceQueryBuffer.toString();
406 when(session.query(copyReferenceQuery, paramsMap)).thenReturn(copyStructuredDataReferencesResult);
407 when(copyStructuredDataReferencesResult.queryStatistics()).thenReturn(queryStatistics);
408 StringBuffer copyPayloadQueryBuffer = new StringBuffer();
409 copyPayloadQueryBuffer.append(
410 "MATCH (v_source:Version)<-[:has_version]-(sdr_source:StructuredDataReference)-[:has_payload]->(sd:StructuredData), "
411 );
412 copyPayloadQueryBuffer.append("(v_target:Version)<-[:has_version]-(sdr_target:StructuredDataReference) ");
413 copyPayloadQueryBuffer.append(
414 "WHERE v_source.uid = '" +
415 sourceVersionUID +
416 "' AND v_target.uid = '" +
417 targetVersionUID +
418 "' AND sdr_source.shepardId = sdr_target.shepardId "
419 );
420 copyPayloadQueryBuffer.append("CREATE (sdr_target)-[:has_payload]->(sd)");
421 String copyPayloadQuery = copyPayloadQueryBuffer.toString();
422 when(session.query(copyPayloadQuery, paramsMap)).thenReturn(copyStructuredDataPayloadResult);
423 when(copyStructuredDataPayloadResult.queryStatistics()).thenReturn(queryStatistics);
424 when(queryStatistics.containsUpdates()).thenReturn(true);
425 dao.copyStructuredDataReferences(sourceVersionUID, targetVersionUID);
426 verify(session).query(copyReferenceQuery, paramsMap);
427 verify(session).query(copyPayloadQuery, paramsMap);
428 }
429
430
431 public void copyTimeseriesReferencesTest() {
432 UUID sourceVersionUID = new UUID(0L, 1L);
433 UUID targetVersionUID = new UUID(2L, 3L);
434 Map<String, Object> paramsMap = new HashMap<>();
435 StringBuffer copyReferenceQueryBuffer = new StringBuffer();
436 copyReferenceQueryBuffer.append(
437 "MATCH (v_source:Version)<-[has_version]-(do_source:DataObject)-[:has_reference]->(tsr_source:TimeseriesReference)-[:is_in_container]->(tsc_pointed:TimeseriesContainer), "
438 );
439 copyReferenceQueryBuffer.append("(tsr_source)-[:created_by]->(u_creator:User), ");
440 copyReferenceQueryBuffer.append("(v_target:Version)<-[:has_version]-(do_target:DataObject) ");
441 copyReferenceQueryBuffer.append(
442 "WHERE v_source.uid = '" +
443 sourceVersionUID +
444 "' AND v_target.uid = '" +
445 targetVersionUID +
446 "' AND do_source.shepardId = do_target.shepardId "
447 );
448 copyReferenceQueryBuffer.append(
449 "CREATE (v_target)<-[:has_version]-(tsr_target:TimeseriesReference:BasicReference:VersionableEntity:BasicEntity)<-[:has_reference]-(do_target), "
450 );
451 copyReferenceQueryBuffer.append("(tsc_pointed)<-[:is_in_container]-(tsr_target)-[:created_by]->(u_creator) ");
452 copyReferenceQueryBuffer.append("SET tsr_target = tsr_source");
453 String copyReferenceQuery = copyReferenceQueryBuffer.toString();
454 when(session.query(copyReferenceQuery, paramsMap)).thenReturn(copyTimeseriesReferencesResult);
455 when(copyTimeseriesReferencesResult.queryStatistics()).thenReturn(queryStatistics);
456 StringBuffer copyPayloadQueryBuffer = new StringBuffer();
457 copyPayloadQueryBuffer.append(
458 "MATCH (v_source:Version)<-[:has_version]-(tsr_source:TimeseriesReference)-[:has_payload]->(ts:Timeseries), "
459 );
460 copyPayloadQueryBuffer.append("(v_target:Version)<-[:has_version]-(tsr_target:TimeseriesReference) ");
461 copyPayloadQueryBuffer.append(
462 "WHERE v_source.uid = '" +
463 sourceVersionUID +
464 "' AND v_target.uid = '" +
465 targetVersionUID +
466 "' AND tsr_source.shepardId = tsr_target.shepardId "
467 );
468 copyPayloadQueryBuffer.append("CREATE (tsr_target)-[:has_payload]->(ts)");
469 String copyPayloadQuery = copyPayloadQueryBuffer.toString();
470 when(session.query(copyPayloadQuery, paramsMap)).thenReturn(copyTimeseriesPayloadResult);
471 when(copyTimeseriesPayloadResult.queryStatistics()).thenReturn(queryStatistics);
472 when(queryStatistics.containsUpdates()).thenReturn(true);
473 dao.copyTimeseriesReferences(sourceVersionUID, targetVersionUID);
474 verify(session).query(copyReferenceQuery, paramsMap);
475 verify(session).query(copyPayloadQuery, paramsMap);
476 }
477
478
479 public void copyCollectionReferencesTest() {
480 UUID sourceVersionUID = new UUID(0L, 1L);
481 UUID targetVersionUID = new UUID(2L, 3L);
482 Map<String, Object> paramsMap = new HashMap<>();
483 StringBuffer queryBuffer = new StringBuffer();
484 queryBuffer.append(
485 "MATCH (v_source:Version)<-[has_version]-(do_source:DataObject)-[:has_reference]->(cr_source:CollectionReference)-[:points_to]->(c_pointed:Collection), "
486 );
487 queryBuffer.append("(cr_source)-[:created_by]->(u_creator:User), ");
488 queryBuffer.append("(v_target:Version)<-[:has_version]-(do_target:DataObject) ");
489 queryBuffer.append(
490 "WHERE v_source.uid = '" +
491 sourceVersionUID +
492 "' AND v_target.uid = '" +
493 targetVersionUID +
494 "' AND do_source.shepardId = do_target.shepardId "
495 );
496 queryBuffer.append(
497 "CREATE (v_target)<-[:has_version]-(cr_target:CollectionReference:BasicReference)<-[:has_reference]-(do_target), "
498 );
499 queryBuffer.append("(c_pointed)<-[:points_to]-(cr_target)-[:created_by]->(u_creator) ");
500 queryBuffer.append("SET cr_target = cr_source");
501 String copyReferenceQuery = queryBuffer.toString();
502 when(session.query(copyReferenceQuery, paramsMap)).thenReturn(copyCollectionReferencesResult);
503 when(copyCollectionReferencesResult.queryStatistics()).thenReturn(queryStatistics);
504 when(queryStatistics.containsUpdates()).thenReturn(true);
505 dao.copyCollectionReferences(sourceVersionUID, targetVersionUID);
506 verify(session).query(copyReferenceQuery, paramsMap);
507 }
508
509
510 public void copyURIReferencesTest() {
511 UUID sourceVersionUID = new UUID(0L, 1L);
512 UUID targetVersionUID = new UUID(2L, 3L);
513 Map<String, Object> paramsMap = new HashMap<>();
514 StringBuffer queryBuffer = new StringBuffer();
515 queryBuffer.append(
516 "MATCH (v_source:Version)<-[:has_version]-(do_source:DataObject)-[:has_reference]->(ur_source:URIReference)-[:created_by]->(u_creator:User), "
517 );
518 queryBuffer.append("(v_target:Version)<-[:has_version]-(do_target:DataObject) ");
519 queryBuffer.append(
520 "WHERE v_source.uid = '" +
521 sourceVersionUID +
522 "' AND v_target.uid = '" +
523 targetVersionUID +
524 "' AND do_source.shepardId = do_target.shepardId "
525 );
526 queryBuffer.append(
527 "CREATE (v_target)<-[:has_version]-(ur_target:URIReference:BasicReference:VersionableEntity:BasicEntity)<-[:has_reference]-(do_target), "
528 );
529 queryBuffer.append("(ur_target)-[:created_by]->(u_creator) ");
530 queryBuffer.append("SET ur_target=ur_source");
531 String copyReferenceQuery = queryBuffer.toString();
532 when(session.query(copyReferenceQuery, paramsMap)).thenReturn(copyURIReferencesResult);
533 when(copyURIReferencesResult.queryStatistics()).thenReturn(queryStatistics);
534 when(queryStatistics.containsUpdates()).thenReturn(true);
535 dao.copyURIReferences(sourceVersionUID, targetVersionUID);
536 verify(session).query(copyReferenceQuery, paramsMap);
537 }
538 }