1 package de.dlr.shepard.common.search.services;
2
3 import static org.junit.jupiter.api.Assertions.assertEquals;
4 import static org.junit.jupiter.api.Assertions.assertThrows;
5 import static org.mockito.ArgumentMatchers.any;
6 import static org.mockito.Mockito.when;
7
8 import com.mongodb.client.FindIterable;
9 import com.mongodb.client.MongoCollection;
10 import com.mongodb.client.MongoDatabase;
11 import de.dlr.shepard.BaseTestCase;
12 import de.dlr.shepard.auth.users.entities.User;
13 import de.dlr.shepard.auth.users.services.UserService;
14 import de.dlr.shepard.common.exceptions.InvalidBodyException;
15 import de.dlr.shepard.common.neo4j.io.BasicEntityIO;
16 import de.dlr.shepard.common.search.io.QueryType;
17 import de.dlr.shepard.common.search.io.ResponseBody;
18 import de.dlr.shepard.common.search.io.ResultTriple;
19 import de.dlr.shepard.common.search.io.SearchBody;
20 import de.dlr.shepard.common.search.io.SearchParams;
21 import de.dlr.shepard.common.search.io.SearchScope;
22 import de.dlr.shepard.common.util.TraversalRules;
23 import de.dlr.shepard.context.collection.entities.DataObject;
24 import de.dlr.shepard.context.references.basicreference.daos.BasicReferenceDAO;
25 import de.dlr.shepard.context.references.structureddata.daos.StructuredDataReferenceDAO;
26 import de.dlr.shepard.context.references.structureddata.entities.StructuredDataReference;
27 import de.dlr.shepard.data.structureddata.entities.StructuredData;
28 import de.dlr.shepard.data.structureddata.entities.StructuredDataContainer;
29 import io.quarkus.test.InjectMock;
30 import io.quarkus.test.component.QuarkusComponentTest;
31 import jakarta.inject.Inject;
32 import jakarta.inject.Named;
33 import java.util.Collections;
34 import java.util.Date;
35 import java.util.List;
36 import org.bson.Document;
37 import org.junit.jupiter.api.Test;
38
39 @QuarkusComponentTest
40 public class StructuredDataSearchServiceTest extends BaseTestCase {
41
42 @InjectMock
43 StructuredDataReferenceDAO structuredDataReferenceDAO;
44
45 @InjectMock
46 BasicReferenceDAO basicReferenceDAO;
47
48 @InjectMock
49 @Named("mongoDatabase")
50 MongoDatabase mongoDatabase;
51
52 @InjectMock
53 MongoCollection<Document> mongoContainer;
54
55 @InjectMock
56 FindIterable<Document> mongoQueryResult;
57
58 @InjectMock
59 Document firstDocument;
60
61 @InjectMock
62 UserService userService;
63
64 @Inject
65 StructuredDataSearchService structuredDataSearcher;
66
67 private final User user = new User("Testuser");
68
69 @Test
70 public void getStructuredDataResponseTest() {
71 Long collectionId = 1L;
72 Long dataObjectId = 2L;
73 String mongoID = "61371f2889b108615688e22e";
74
75 DataObject dataObject = new DataObject(dataObjectId);
76 dataObject.setShepardId(dataObject.getId());
77 List<StructuredData> structuredDatas = List.of(new StructuredData("61371f2889b108615688e22e", new Date(), "name"));
78 StructuredDataContainer sdContainer = new StructuredDataContainer(2L);
79 sdContainer.setMongoId(mongoID);
80 StructuredDataReference sdReference = new StructuredDataReference() {
81 {
82 setId(3L);
83 setShepardId(3L);
84 setDeleted(false);
85 setName("reference1");
86 setStructuredDatas(structuredDatas);
87 setStructuredDataContainer(sdContainer);
88 setDataObject(dataObject);
89 }
90 };
91
92 TraversalRules[] traversalRules = {};
93 SearchScope scope = new SearchScope(collectionId, dataObjectId, traversalRules);
94 SearchScope scopes[] = { scope };
95 String query = "xwert: {$gt: 0}";
96 QueryType queryType = QueryType.StructuredData;
97 SearchParams searchParams = new SearchParams(query, queryType);
98 SearchBody searchBody = new SearchBody(scopes, searchParams);
99
100 ResultTriple resultTriple = new ResultTriple(1L, 2L, 3L);
101 ResultTriple[] resultTriples = { resultTriple };
102 BasicEntityIO[] results = { new BasicEntityIO(sdReference) };
103 ResponseBody responseBody = new ResponseBody(resultTriples, results, searchBody.getSearchParams());
104
105 when(
106 structuredDataReferenceDAO.findReachableReferencesByNeo4jId(collectionId, dataObjectId, user.getUsername())
107 ).thenReturn(List.of(sdReference));
108 when(mongoDatabase.getCollection(mongoID)).thenReturn(mongoContainer);
109 when(mongoContainer.find(any(Document.class))).thenReturn(mongoQueryResult);
110 when(mongoQueryResult.first()).thenReturn(firstDocument);
111 when(userService.getCurrentUser()).thenReturn(user);
112
113 var actual = structuredDataSearcher.search(searchBody);
114 assertEquals(responseBody, actual);
115 }
116
117 @Test
118 public void getStructuredDataResponseTest_TraversalRules() {
119 Long collectionId = 1L;
120 Long dataObjectId = 2L;
121 String mongoID = "61371f2889b108615688e22e";
122
123 DataObject dataObject = new DataObject(dataObjectId);
124 dataObject.setShepardId(dataObject.getId());
125 List<StructuredData> structuredDatas = List.of(new StructuredData("61371f2889b108615688e22e", new Date(), "name"));
126 StructuredDataContainer sdContainer = new StructuredDataContainer(2L);
127 sdContainer.setMongoId(mongoID);
128 StructuredDataReference sdReference = new StructuredDataReference() {
129 {
130 setId(3L);
131 setShepardId(3L);
132 setDeleted(false);
133 setName("reference1");
134 setStructuredDatas(structuredDatas);
135 setStructuredDataContainer(sdContainer);
136 setDataObject(dataObject);
137 }
138 };
139
140 TraversalRules[] traversalRules = { TraversalRules.children };
141 SearchScope scope = new SearchScope(collectionId, dataObjectId, traversalRules);
142 SearchScope scopes[] = { scope };
143 String query = "xwert: {$gt: 0}";
144 QueryType queryType = QueryType.StructuredData;
145 SearchParams searchParams = new SearchParams(query, queryType);
146 SearchBody searchBody = new SearchBody(scopes, searchParams);
147
148 ResultTriple resultTriple = new ResultTriple(1L, 2L, 3L);
149 ResultTriple[] resultTriples = { resultTriple };
150 BasicEntityIO[] results = { new BasicEntityIO(sdReference) };
151 ResponseBody responseBody = new ResponseBody(resultTriples, results, searchBody.getSearchParams());
152
153 when(
154 structuredDataReferenceDAO.findReachableReferencesByNeo4jId(
155 TraversalRules.children,
156 collectionId,
157 dataObjectId,
158 user.getUsername()
159 )
160 ).thenReturn(List.of(sdReference));
161 when(mongoDatabase.getCollection(mongoID)).thenReturn(mongoContainer);
162 when(mongoContainer.find(any(Document.class))).thenReturn(mongoQueryResult);
163 when(mongoQueryResult.first()).thenReturn(firstDocument);
164 when(userService.getCurrentUser()).thenReturn(user);
165
166 var actual = structuredDataSearcher.search(searchBody);
167 assertEquals(responseBody, actual);
168 }
169
170 @Test
171 public void getStructuredDataResponseTest_JsonQuery() {
172 Long collectionId = 1L;
173 Long dataObjectId = 2L;
174 String mongoID = "61371f2889b108615688e22e";
175
176 DataObject dataObject = new DataObject(dataObjectId);
177 dataObject.setShepardId(dataObject.getId());
178 List<StructuredData> structuredDatas = List.of(new StructuredData("61371f2889b108615688e22e", new Date(), "name"));
179 StructuredDataContainer sdContainer = new StructuredDataContainer(2L);
180 sdContainer.setMongoId(mongoID);
181 StructuredDataReference sdReference = new StructuredDataReference() {
182 {
183 setId(3L);
184 setShepardId(3L);
185 setDeleted(false);
186 setName("reference1");
187 setStructuredDatas(structuredDatas);
188 setStructuredDataContainer(sdContainer);
189 setDataObject(dataObject);
190 }
191 };
192
193 TraversalRules[] traversalRules = {};
194 SearchScope scope = new SearchScope(collectionId, dataObjectId, traversalRules);
195 SearchScope scopes[] = { scope };
196 String query =
197 """
198 {
199 "property": "name",
200 "value": "MyName",
201 "operator": "eq"
202 }
203 """;
204 QueryType queryType = QueryType.StructuredData;
205 SearchParams searchParams = new SearchParams(query, queryType);
206 SearchBody searchBody = new SearchBody(scopes, searchParams);
207
208 ResultTriple resultTriple = new ResultTriple(1L, 2L, 3L);
209 ResultTriple[] resultTriples = { resultTriple };
210 BasicEntityIO[] results = { new BasicEntityIO(sdReference) };
211 ResponseBody responseBody = new ResponseBody(resultTriples, results, searchBody.getSearchParams());
212
213 when(
214 structuredDataReferenceDAO.findReachableReferencesByNeo4jId(collectionId, dataObjectId, user.getUsername())
215 ).thenReturn(List.of(sdReference));
216 when(userService.getCurrentUser()).thenReturn(user);
217 when(mongoDatabase.getCollection(mongoID)).thenReturn(mongoContainer);
218 when(mongoContainer.find(any(Document.class))).thenReturn(mongoQueryResult);
219 when(mongoQueryResult.first()).thenReturn(firstDocument);
220
221 var actual = structuredDataSearcher.search(searchBody);
222 assertEquals(responseBody, actual);
223 }
224
225 @Test
226 public void getStructuredDataResponseTest_NoReferences() {
227
228 Long collectionId = 1L;
229 Long dataObjectId = 2L;
230 TraversalRules[] traversalRules = {};
231 SearchScope scope = new SearchScope(collectionId, dataObjectId, traversalRules);
232 SearchScope scopes[] = { scope };
233 String query = "xwert: {$gt: 0}";
234 QueryType queryType = QueryType.StructuredData;
235 SearchParams searchParams = new SearchParams(query, queryType);
236 SearchBody searchBody = new SearchBody(scopes, searchParams);
237
238 ResultTriple[] resultTriples = {};
239 BasicEntityIO[] results = {};
240 ResponseBody responseBody = new ResponseBody(resultTriples, results, searchBody.getSearchParams());
241
242 when(
243 structuredDataReferenceDAO.findReachableReferencesByShepardId(collectionId, dataObjectId, user.getUsername())
244 ).thenReturn(Collections.emptyList());
245 when(userService.getCurrentUser()).thenReturn(user);
246
247 var actual = structuredDataSearcher.search(searchBody);
248 assertEquals(responseBody, actual);
249 }
250
251 @Test
252 public void getStructuredDataResponseTest_NoMatches() {
253 Long collectionId = 1L;
254 Long dataObjectId = 2L;
255 String mongoID = "61371f2889b108615688e22e";
256
257 DataObject dataObject = new DataObject(dataObjectId);
258 dataObject.setShepardId(dataObject.getId());
259 List<StructuredData> structuredDatas = List.of(new StructuredData("61371f2889b108615688e22e", new Date(), "name"));
260 StructuredDataContainer sdContainer = new StructuredDataContainer(2L);
261 sdContainer.setMongoId(mongoID);
262 StructuredDataReference sdReference = new StructuredDataReference() {
263 {
264 setId(3L);
265 setShepardId(3L);
266 setDeleted(false);
267 setName("reference1");
268 setStructuredDatas(structuredDatas);
269 setStructuredDataContainer(sdContainer);
270 setDataObject(dataObject);
271 }
272 };
273
274 TraversalRules[] traversalRules = {};
275 SearchScope scope = new SearchScope(collectionId, dataObjectId, traversalRules);
276 SearchScope scopes[] = { scope };
277 String query = "xwert: {$gt: 0}";
278 QueryType queryType = QueryType.StructuredData;
279 SearchParams searchParams = new SearchParams(query, queryType);
280 SearchBody searchBody = new SearchBody(scopes, searchParams);
281
282 ResultTriple[] resultTriples = {};
283 BasicEntityIO[] results = {};
284 ResponseBody responseBody = new ResponseBody(resultTriples, results, searchBody.getSearchParams());
285
286 when(
287 structuredDataReferenceDAO.findReachableReferencesByShepardId(collectionId, dataObjectId, user.getUsername())
288 ).thenReturn(List.of(sdReference));
289 when(mongoDatabase.getCollection(mongoID)).thenReturn(mongoContainer);
290 when(mongoContainer.find(any(Document.class))).thenReturn(mongoQueryResult);
291 when(mongoQueryResult.first()).thenReturn(null);
292 when(userService.getCurrentUser()).thenReturn(user);
293
294 var actual = structuredDataSearcher.search(searchBody);
295 assertEquals(responseBody, actual);
296 }
297
298 @Test
299 public void throwsExeption() {
300 SearchScope[] scope = { new SearchScope(null, 1L, null) };
301 SearchBody searchBody = new SearchBody(scope, null);
302
303 when(userService.getCurrentUser()).thenReturn(user);
304
305 assertThrows(InvalidBodyException.class, () -> structuredDataSearcher.search(searchBody));
306 }
307
308 @Test
309 public void getStructuredDataResponseTestWithoutCollectionId() {
310 Long collectionId = 1L;
311 Long dataObjectId = 2L;
312 String mongoID = "61371f2889b108615688e22e";
313
314 DataObject dataObject = new DataObject(dataObjectId);
315 dataObject.setShepardId(dataObject.getId());
316 List<StructuredData> structuredDatas = List.of(new StructuredData("61371f2889b108615688e22e", new Date(), "name"));
317 StructuredDataContainer sdContainer = new StructuredDataContainer(2L);
318 sdContainer.setMongoId(mongoID);
319 StructuredDataReference sdReference = new StructuredDataReference() {
320 {
321 setId(3L);
322 setShepardId(3L);
323 setDeleted(false);
324 setName("reference1");
325 setStructuredDatas(structuredDatas);
326 setStructuredDataContainer(sdContainer);
327 setDataObject(dataObject);
328 }
329 };
330
331 SearchScope scope = new SearchScope(collectionId, null, null);
332 SearchScope scopes[] = { scope };
333 String query = "xwert: {$gt: 0}";
334 QueryType queryType = QueryType.StructuredData;
335 SearchParams searchParams = new SearchParams(query, queryType);
336 SearchBody searchBody = new SearchBody(scopes, searchParams);
337
338 ResultTriple resultTriple = new ResultTriple(1L, 2L, 3L);
339 ResultTriple[] resultTriples = { resultTriple };
340 BasicEntityIO[] results = { new BasicEntityIO(sdReference) };
341 ResponseBody responseBody = new ResponseBody(resultTriples, results, searchBody.getSearchParams());
342
343 when(structuredDataReferenceDAO.findReachableReferencesByNeo4jId(collectionId, user.getUsername())).thenReturn(
344 List.of(sdReference)
345 );
346 when(mongoDatabase.getCollection(mongoID)).thenReturn(mongoContainer);
347 when(mongoContainer.find(any(Document.class))).thenReturn(mongoQueryResult);
348 when(mongoQueryResult.first()).thenReturn(firstDocument);
349 when(userService.getCurrentUser()).thenReturn(user);
350
351 var actual = structuredDataSearcher.search(searchBody);
352 assertEquals(responseBody, actual);
353 }
354 }