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