1 package de.dlr.shepard.common.search.daos;
2
3 import static org.junit.jupiter.api.Assertions.assertEquals;
4 import static org.mockito.Mockito.when;
5
6 import de.dlr.shepard.BaseTestCase;
7 import de.dlr.shepard.auth.users.entities.User;
8 import de.dlr.shepard.auth.users.entities.UserGroup;
9 import de.dlr.shepard.common.neo4j.entities.BasicContainer;
10 import de.dlr.shepard.context.collection.entities.Collection;
11 import de.dlr.shepard.context.collection.entities.DataObject;
12 import de.dlr.shepard.context.references.basicreference.entities.BasicReference;
13 import de.dlr.shepard.data.file.entities.FileContainer;
14 import de.dlr.shepard.data.structureddata.entities.StructuredDataContainer;
15 import de.dlr.shepard.data.timeseries.model.TimeseriesContainer;
16 import java.util.Arrays;
17 import java.util.Collections;
18 import java.util.List;
19 import org.junit.jupiter.api.Test;
20 import org.mockito.InjectMocks;
21 import org.mockito.Mock;
22 import org.neo4j.ogm.session.Session;
23
24 public class SearchDAOTest extends BaseTestCase {
25
26 @Mock
27 private Session session;
28
29 @InjectMocks
30 private SearchDAO dao;
31
32 @Test
33 public void findCollectionsTest() {
34 var collections = List.of(new Collection(1L));
35 String query =
36 "Match bla WITH col MATCH path=(col)-[*0..1]->(n) WHERE n:Permission OR n:User RETURN col, nodes(path), relationships(path)";
37 when(session.query(Collection.class, query, Collections.emptyMap())).thenReturn(collections);
38 var actual = dao.findCollections("Match bla", null, "col");
39 assertEquals(collections, actual);
40 }
41
42 @Test
43 public void findDataObjectsTest() {
44 var dataObjects = List.of(new DataObject(1L));
45 String query =
46 "Match bla WITH do MATCH path=(c:Collection)-[]->(do)-[]->(u:User) RETURN do, nodes(path), relationships(path)";
47 when(session.query(DataObject.class, query, Collections.emptyMap())).thenReturn(dataObjects);
48 var actual = dao.findDataObjects("Match bla", "do");
49 assertEquals(dataObjects, actual);
50 }
51
52 @Test
53 public void findReferencesTest() {
54 var references = List.of(new BasicReference(1L));
55 String query =
56 "Match bla WITH ref MATCH path=(c:Collection)-[]->(d:DataObject)-[]->(ref)-[]->(u:User) RETURN ref, nodes(path), relationships(path)";
57 when(session.query(BasicReference.class, query, Collections.emptyMap())).thenReturn(references);
58 var actual = dao.findReferences("Match bla", "ref");
59 assertEquals(references, actual);
60 }
61
62 @Test
63 public void getContainerTotalCountTest() {
64 int containerCount = 1;
65 Iterable<Integer> countIterable = () -> Arrays.stream(new Integer[] { containerCount }).iterator();
66 String selectionQuery = "MATCH bla";
67 String query = "MATCH bla WITH bc MATCH path=(bc)-[*0..1]->(n) WHERE n:Permission OR n:User RETURN COUNT(bc)";
68 when(session.query(Integer.class, query, Collections.emptyMap())).thenReturn(countIterable);
69 var actual = dao.getContainerTotalCount(selectionQuery, "bc");
70 assertEquals(containerCount, actual);
71 }
72
73 @Test
74 public void findBasicContainersTest() {
75 List<BasicContainer> basicContainers = List.of(new BasicContainer(1L));
76 String selectionQuery = "MATCH bla";
77 String query =
78 "MATCH bla WITH bc MATCH path=(bc)-[*0..1]->(n) WHERE n:Permission OR n:User RETURN bc, nodes(path), relationships(path)";
79 when(session.query(BasicContainer.class, query, Collections.emptyMap())).thenReturn(basicContainers);
80 var actual = dao.findContainers(selectionQuery, null, "bc");
81 assertEquals(basicContainers, actual);
82 }
83
84 @Test
85 public void findFileContainersTest() {
86 List<BasicContainer> fileContainers = List.of(new FileContainer(1L));
87 String selectionQuery = "MATCH bla";
88 String query =
89 "MATCH bla WITH fc MATCH path=(fc)-[*0..1]->(n) WHERE n:Permission OR n:User RETURN fc, nodes(path), relationships(path)";
90 when(session.query(BasicContainer.class, query, Collections.emptyMap())).thenReturn(fileContainers);
91 var actual = dao.findContainers(selectionQuery, null, "fc");
92 assertEquals(fileContainers, actual);
93 }
94
95 @Test
96 public void findStructuredDataContainersTest() {
97 List<BasicContainer> structuredDataContainers = List.of(new StructuredDataContainer(1L));
98 String selectionQuery = "MATCH bla";
99 String query =
100 "MATCH bla WITH sd MATCH path=(sd)-[*0..1]->(n) WHERE n:Permission OR n:User RETURN sd, nodes(path), relationships(path)";
101 when(session.query(BasicContainer.class, query, Collections.emptyMap())).thenReturn(structuredDataContainers);
102 var actual = dao.findContainers(selectionQuery, null, "sd");
103 assertEquals(structuredDataContainers, actual);
104 }
105
106 @Test
107 public void findTimeseriesContainersTest() {
108 List<BasicContainer> timeseriesContainers = List.of(new TimeseriesContainer(1L));
109 String selectionQuery = "MATCH bla";
110 String query =
111 "MATCH bla WITH ts MATCH path=(ts)-[*0..1]->(n) WHERE n:Permission OR n:User RETURN ts, nodes(path), relationships(path)";
112 when(session.query(BasicContainer.class, query, Collections.emptyMap())).thenReturn(timeseriesContainers);
113 var actual = dao.findContainers(selectionQuery, null, "ts");
114 assertEquals(timeseriesContainers, actual);
115 }
116
117 @Test
118 public void findUsersTest() {
119 var users = List.of(new User("user"));
120 String selectionQuery = "MATCH bla";
121 String query =
122 "MATCH bla WITH user MATCH path=(user:User)<-[:belongs_to|subscribed_by*0..1]-(n) RETURN user, nodes(path), relationships(path)";
123 when(session.query(User.class, query, Collections.emptyMap())).thenReturn(users);
124 var actual = dao.findUsers(selectionQuery, "user");
125 assertEquals(users, actual);
126 }
127
128 @Test
129 public void findUserGroupsTest() {
130 var userGroups = List.of(new UserGroup(123));
131 String selectionQuery = "MATCH bla";
132 String query =
133 "MATCH bla WITH userGroup MATCH path=(userGroup:UserGroup)<-[:belongs_to|subscribed_by*0..1]-(n) RETURN userGroup, nodes(path), relationships(path)";
134 when(session.query(UserGroup.class, query, Collections.emptyMap())).thenReturn(userGroups);
135 var actual = dao.findUserGroups(selectionQuery, "userGroup");
136 assertEquals(userGroups, actual);
137 }
138 }