1 package de.dlr.shepard.data.timeseries;
2
3 import static org.junit.jupiter.api.Assertions.assertEquals;
4 import static org.mockito.Mockito.verify;
5 import static org.mockito.Mockito.when;
6
7 import de.dlr.shepard.BaseTestCase;
8 import de.dlr.shepard.common.util.QueryParamHelper;
9 import de.dlr.shepard.data.ContainerAttributes;
10 import de.dlr.shepard.data.timeseries.daos.TimeseriesContainerDAO;
11 import de.dlr.shepard.data.timeseries.model.TimeseriesContainer;
12 import java.util.HashMap;
13 import java.util.List;
14 import java.util.Map;
15 import org.junit.jupiter.api.Test;
16 import org.mockito.InjectMocks;
17 import org.mockito.Mock;
18 import org.neo4j.ogm.session.Session;
19
20 public class TimeseriesContainerDAOTest extends BaseTestCase {
21
22 @Mock
23 private Session session;
24
25 @InjectMocks
26 private TimeseriesContainerDAO dao;
27
28 @Test
29 public void getEntityTypeTest() {
30 var type = dao.getEntityType();
31 assertEquals(TimeseriesContainer.class, type);
32 }
33
34 @Test
35 public void findAll_WithoutName() {
36 var col1 = new TimeseriesContainer(1L);
37 col1.setName("Yes");
38 Map<String, Object> paramsMap = new HashMap<>();
39 paramsMap.put("name", null);
40
41 var query =
42 """
43 MATCH (c:TimeseriesContainer { deleted: FALSE }) WHERE (NOT exists((c)-[:has_permissions]->(:Permissions)) \
44 OR exists((c)-[:has_permissions]->(:Permissions)-[:readable_by|owned_by]->(:User { username: "bob" })) \
45 OR exists((c)-[:has_permissions]->(:Permissions {permissionType: "Public"})) \
46 OR exists((c)-[:has_permissions]->(:Permissions {permissionType: "PublicReadable"})) \
47 OR exists((c)-[:has_permissions]->(:Permissions)-[:readable_by_group]->(:UserGroup)<-[:is_in_group]-(:User { username: "bob"}))) \
48 WITH c MATCH path=(c)-[*0..1]->(n) WHERE n:Permission OR n:User RETURN c, nodes(path), relationships(path)""";
49 when(session.query(TimeseriesContainer.class, query, paramsMap)).thenReturn(List.of(col1));
50
51 var params = new QueryParamHelper();
52 var actual = dao.findAllTimeseriesContainers(params, "bob");
53 verify(session).query(TimeseriesContainer.class, query, paramsMap);
54 assertEquals(List.of(col1), actual);
55 }
56
57 @Test
58 public void findAll_WithoutNameOrderByNameDesc() {
59 var col1 = new TimeseriesContainer(1L);
60 col1.setName("Yes");
61 Map<String, Object> paramsMap = new HashMap<>();
62 paramsMap.put("name", null);
63
64 var query =
65 """
66 MATCH (c:TimeseriesContainer { deleted: FALSE }) WHERE (NOT exists((c)-[:has_permissions]->(:Permissions)) \
67 OR exists((c)-[:has_permissions]->(:Permissions)-[:readable_by|owned_by]->(:User { username: "bob" })) \
68 OR exists((c)-[:has_permissions]->(:Permissions {permissionType: "Public"})) \
69 OR exists((c)-[:has_permissions]->(:Permissions {permissionType: "PublicReadable"})) \
70 OR exists((c)-[:has_permissions]->(:Permissions)-[:readable_by_group]->(:UserGroup)<-[:is_in_group]-(:User { username: "bob"}))) \
71 WITH c ORDER BY toLower(c.name) DESC \
72 MATCH path=(c)-[*0..1]->(n) WHERE n:Permission OR n:User RETURN c, nodes(path), relationships(path)""";
73 when(session.query(TimeseriesContainer.class, query, paramsMap)).thenReturn(List.of(col1));
74
75 var params = new QueryParamHelper();
76 var attr = ContainerAttributes.name;
77 params = params.withOrderByAttribute(attr, true);
78 var actual = dao.findAllTimeseriesContainers(params, "bob");
79 verify(session).query(TimeseriesContainer.class, query, paramsMap);
80 assertEquals(List.of(col1), actual);
81 }
82
83 @Test
84 public void findAll_WithName() {
85 var col1 = new TimeseriesContainer(1L);
86 col1.setName("Yes");
87 var col2 = new TimeseriesContainer(2L);
88 col2.setName("No");
89 Map<String, Object> paramsMap = new HashMap<>();
90 paramsMap.put("name", "Yes");
91
92 var query =
93 """
94 MATCH (c:TimeseriesContainer { name : $name, deleted: FALSE }) WHERE (NOT exists((c)-[:has_permissions]->(:Permissions)) \
95 OR exists((c)-[:has_permissions]->(:Permissions)-[:readable_by|owned_by]->(:User { username: "bob" })) \
96 OR exists((c)-[:has_permissions]->(:Permissions {permissionType: "Public"})) \
97 OR exists((c)-[:has_permissions]->(:Permissions {permissionType: "PublicReadable"})) \
98 OR exists((c)-[:has_permissions]->(:Permissions)-[:readable_by_group]->(:UserGroup)<-[:is_in_group]-(:User { username: "bob"}))) \
99 WITH c MATCH path=(c)-[*0..1]->(n) WHERE n:Permission OR n:User RETURN c, nodes(path), relationships(path)""";
100 when(session.query(TimeseriesContainer.class, query, paramsMap)).thenReturn(List.of(col1, col2));
101
102 var params = new QueryParamHelper().withName("Yes");
103 var actual = dao.findAllTimeseriesContainers(params, "bob");
104 verify(session).query(TimeseriesContainer.class, query, paramsMap);
105 assertEquals(List.of(col1), actual);
106 }
107
108 @Test
109 public void findAll_WithNameOrderByNameDesc() {
110 var col1 = new TimeseriesContainer(1L);
111 col1.setName("Yes");
112 var col2 = new TimeseriesContainer(2L);
113 col2.setName("No");
114 Map<String, Object> paramsMap = new HashMap<>();
115 paramsMap.put("name", "Yes");
116
117 var query =
118 """
119 MATCH (c:TimeseriesContainer { name : $name, deleted: FALSE }) WHERE (NOT exists((c)-[:has_permissions]->(:Permissions)) \
120 OR exists((c)-[:has_permissions]->(:Permissions)-[:readable_by|owned_by]->(:User { username: "bob" })) \
121 OR exists((c)-[:has_permissions]->(:Permissions {permissionType: "Public"})) \
122 OR exists((c)-[:has_permissions]->(:Permissions {permissionType: "PublicReadable"})) \
123 OR exists((c)-[:has_permissions]->(:Permissions)-[:readable_by_group]->(:UserGroup)<-[:is_in_group]-(:User { username: "bob"}))) \
124 WITH c ORDER BY toLower(c.name) DESC \
125 MATCH path=(c)-[*0..1]->(n) WHERE n:Permission OR n:User RETURN c, nodes(path), relationships(path)""";
126 when(session.query(TimeseriesContainer.class, query, paramsMap)).thenReturn(List.of(col1, col2));
127
128 var params = new QueryParamHelper().withName("Yes");
129 var attr = ContainerAttributes.name;
130 params = params.withOrderByAttribute(attr, true);
131 var actual = dao.findAllTimeseriesContainers(params, "bob");
132 verify(session).query(TimeseriesContainer.class, query, paramsMap);
133 assertEquals(List.of(col1), actual);
134 }
135
136 @Test
137 public void findAll_WithPage() {
138 var col1 = new TimeseriesContainer(1L);
139 col1.setName("Yes");
140 Map<String, Object> paramsMap = new HashMap<>();
141 paramsMap.put("name", null);
142 paramsMap.put("offset", 300);
143 paramsMap.put("size", 100);
144
145 var query =
146 """
147 MATCH (c:TimeseriesContainer { deleted: FALSE }) WHERE (NOT exists((c)-[:has_permissions]->(:Permissions)) \
148 OR exists((c)-[:has_permissions]->(:Permissions)-[:readable_by|owned_by]->(:User { username: "bob" })) \
149 OR exists((c)-[:has_permissions]->(:Permissions {permissionType: "Public"})) \
150 OR exists((c)-[:has_permissions]->(:Permissions {permissionType: "PublicReadable"})) \
151 OR exists((c)-[:has_permissions]->(:Permissions)-[:readable_by_group]->(:UserGroup)<-[:is_in_group]-(:User { username: "bob"}))) \
152 WITH c SKIP $offset LIMIT $size \
153 MATCH path=(c)-[*0..1]->(n) WHERE n:Permission OR n:User RETURN c, nodes(path), relationships(path)""";
154 when(session.query(TimeseriesContainer.class, query, paramsMap)).thenReturn(List.of(col1));
155
156 var params = new QueryParamHelper().withPageAndSize(3, 100);
157 var actual = dao.findAllTimeseriesContainers(params, "bob");
158 verify(session).query(TimeseriesContainer.class, query, paramsMap);
159 assertEquals(List.of(col1), actual);
160 }
161
162 @Test
163 public void findAll_WithPageOrderByNameDesc() {
164 var col1 = new TimeseriesContainer(1L);
165 col1.setName("Yes");
166 Map<String, Object> paramsMap = new HashMap<>();
167 paramsMap.put("name", null);
168 paramsMap.put("offset", 300);
169 paramsMap.put("size", 100);
170
171 var query =
172 """
173 MATCH (c:TimeseriesContainer { deleted: FALSE }) WHERE (NOT exists((c)-[:has_permissions]->(:Permissions)) \
174 OR exists((c)-[:has_permissions]->(:Permissions)-[:readable_by|owned_by]->(:User { username: "bob" })) \
175 OR exists((c)-[:has_permissions]->(:Permissions {permissionType: "Public"})) \
176 OR exists((c)-[:has_permissions]->(:Permissions {permissionType: "PublicReadable"})) \
177 OR exists((c)-[:has_permissions]->(:Permissions)-[:readable_by_group]->(:UserGroup)<-[:is_in_group]-(:User { username: "bob"}))) \
178 WITH c ORDER BY toLower(c.name) DESC SKIP $offset LIMIT $size \
179 MATCH path=(c)-[*0..1]->(n) WHERE n:Permission OR n:User RETURN c, nodes(path), relationships(path)""";
180 when(session.query(TimeseriesContainer.class, query, paramsMap)).thenReturn(List.of(col1));
181
182 var params = new QueryParamHelper().withPageAndSize(3, 100);
183 var attr = ContainerAttributes.name;
184 params = params.withOrderByAttribute(attr, true);
185 var actual = dao.findAllTimeseriesContainers(params, "bob");
186 verify(session).query(TimeseriesContainer.class, query, paramsMap);
187 assertEquals(List.of(col1), actual);
188 }
189
190 @Test
191 public void findAll_WithNameAndPage() {
192 var col1 = new TimeseriesContainer(1L);
193 col1.setName("Yes");
194 var col2 = new TimeseriesContainer(2L);
195 col2.setName("No");
196 Map<String, Object> paramsMap = new HashMap<>();
197 paramsMap.put("name", "Yes");
198 paramsMap.put("offset", 300);
199 paramsMap.put("size", 100);
200
201 var query =
202 """
203 MATCH (c:TimeseriesContainer { name : $name, deleted: FALSE }) WHERE (NOT exists((c)-[:has_permissions]->(:Permissions)) \
204 OR exists((c)-[:has_permissions]->(:Permissions)-[:readable_by|owned_by]->(:User { username: "bob" })) \
205 OR exists((c)-[:has_permissions]->(:Permissions {permissionType: "Public"})) \
206 OR exists((c)-[:has_permissions]->(:Permissions {permissionType: "PublicReadable"})) \
207 OR exists((c)-[:has_permissions]->(:Permissions)-[:readable_by_group]->(:UserGroup)<-[:is_in_group]-(:User { username: "bob"}))) \
208 WITH c SKIP $offset LIMIT $size \
209 MATCH path=(c)-[*0..1]->(n) WHERE n:Permission OR n:User RETURN c, nodes(path), relationships(path)""";
210 when(session.query(TimeseriesContainer.class, query, paramsMap)).thenReturn(List.of(col1, col2));
211
212 var params = new QueryParamHelper().withPageAndSize(3, 100).withName("Yes");
213 var actual = dao.findAllTimeseriesContainers(params, "bob");
214 verify(session).query(TimeseriesContainer.class, query, paramsMap);
215 assertEquals(List.of(col1), actual);
216 }
217
218 @Test
219 public void findAll_WithNameAndPageOrderByNameDesc() {
220 var col1 = new TimeseriesContainer(1L);
221 col1.setName("Yes");
222 var col2 = new TimeseriesContainer(2L);
223 col2.setName("No");
224 Map<String, Object> paramsMap = new HashMap<>();
225 paramsMap.put("name", "Yes");
226 paramsMap.put("offset", 300);
227 paramsMap.put("size", 100);
228
229 var query =
230 """
231 MATCH (c:TimeseriesContainer { name : $name, deleted: FALSE }) WHERE (NOT exists((c)-[:has_permissions]->(:Permissions)) \
232 OR exists((c)-[:has_permissions]->(:Permissions)-[:readable_by|owned_by]->(:User { username: "bob" })) \
233 OR exists((c)-[:has_permissions]->(:Permissions {permissionType: "Public"})) \
234 OR exists((c)-[:has_permissions]->(:Permissions {permissionType: "PublicReadable"})) \
235 OR exists((c)-[:has_permissions]->(:Permissions)-[:readable_by_group]->(:UserGroup)<-[:is_in_group]-(:User { username: "bob"}))) \
236 WITH c ORDER BY toLower(c.name) DESC SKIP $offset LIMIT $size \
237 MATCH path=(c)-[*0..1]->(n) WHERE n:Permission OR n:User RETURN c, nodes(path), relationships(path)""";
238 when(session.query(TimeseriesContainer.class, query, paramsMap)).thenReturn(List.of(col1, col2));
239
240 var params = new QueryParamHelper().withPageAndSize(3, 100).withName("Yes");
241 var attr = ContainerAttributes.name;
242 params = params.withOrderByAttribute(attr, true);
243 var actual = dao.findAllTimeseriesContainers(params, "bob");
244 verify(session).query(TimeseriesContainer.class, query, paramsMap);
245 assertEquals(List.of(col1), actual);
246 }
247 }