1 package de.dlr.shepard.context.semantic.services;
2
3 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
4 import static org.junit.jupiter.api.Assertions.assertEquals;
5 import static org.junit.jupiter.api.Assertions.assertThrows;
6 import static org.mockito.Mockito.verify;
7 import static org.mockito.Mockito.when;
8
9 import de.dlr.shepard.auth.users.entities.User;
10 import de.dlr.shepard.auth.users.services.UserService;
11 import de.dlr.shepard.common.exceptions.InvalidBodyException;
12 import de.dlr.shepard.common.exceptions.InvalidPathException;
13 import de.dlr.shepard.common.util.DateHelper;
14 import de.dlr.shepard.common.util.QueryParamHelper;
15 import de.dlr.shepard.context.semantic.ISemanticRepositoryConnector;
16 import de.dlr.shepard.context.semantic.SemanticRepositoryConnectorFactory;
17 import de.dlr.shepard.context.semantic.SemanticRepositoryType;
18 import de.dlr.shepard.context.semantic.daos.SemanticRepositoryDAO;
19 import de.dlr.shepard.context.semantic.entities.SemanticRepository;
20 import de.dlr.shepard.context.semantic.io.SemanticRepositoryIO;
21 import io.quarkus.test.InjectMock;
22 import io.quarkus.test.component.QuarkusComponentTest;
23 import jakarta.inject.Inject;
24 import java.util.Date;
25 import java.util.List;
26 import org.junit.jupiter.api.BeforeEach;
27 import org.junit.jupiter.api.Test;
28
29 @QuarkusComponentTest
30 public class SemanticRepositoryServiceTest {
31
32 @InjectMock
33 SemanticRepositoryDAO semanticRepositoryDAO;
34
35 @InjectMock
36 DateHelper dateHelper;
37
38 @InjectMock
39 UserService userService;
40
41 @InjectMock
42 SemanticRepositoryConnectorFactory semanticRepositoryConnectorFactory;
43
44 @InjectMock
45 ISemanticRepositoryConnector semanticRepositoryConnector;
46
47 @Inject
48 SemanticRepositoryService service;
49
50 private final User user = new User("Testuser");
51
52 @BeforeEach
53 public void setUpRepositories() {
54 when(
55 semanticRepositoryConnectorFactory.getRepositoryService(SemanticRepositoryType.SPARQL, "http://test.org")
56 ).thenReturn(semanticRepositoryConnector);
57 }
58
59 @Test
60 public void getAllRepositoriesTest() {
61 var expected = List.of(new SemanticRepository(1L));
62
63 when(semanticRepositoryDAO.findAllSemanticRepositories(null)).thenReturn(expected);
64 var actual = service.getAllRepositories(null);
65
66 assertEquals(expected, actual);
67 }
68
69 @Test
70 public void getAllRepositoryByName() {
71 QueryParamHelper params = new QueryParamHelper();
72 params = params.withName("name");
73 var expected = List.of(new SemanticRepository(1L));
74 when(semanticRepositoryDAO.findAllSemanticRepositories(params)).thenReturn(expected);
75 var actual = service.getAllRepositories(params);
76 assertEquals(expected, actual);
77 }
78
79 @Test
80 public void getRepositoryTest() {
81 var expected = new SemanticRepository(1L);
82
83 when(semanticRepositoryDAO.findByNeo4jId(1L)).thenReturn(expected);
84 var actual = service.getRepository(1L);
85
86 assertEquals(expected, actual);
87 }
88
89 @Test
90 public void getRepositoryTest_isNull() {
91 when(semanticRepositoryDAO.findByNeo4jId(1L)).thenReturn(null);
92
93 var ex = assertThrows(InvalidPathException.class, () -> service.getRepository(1L));
94 assertEquals("ID ERROR - Semantic Repository with id 1 is null or deleted", ex.getMessage());
95 }
96
97 @Test
98 public void getRepositoryTest_isDeleted() {
99 var expected = new SemanticRepository(1L);
100 expected.setDeleted(true);
101
102 when(semanticRepositoryDAO.findByNeo4jId(1L)).thenReturn(expected);
103
104 var ex = assertThrows(InvalidPathException.class, () -> service.getRepository(1L));
105 assertEquals("ID ERROR - Semantic Repository with id 1 is null or deleted", ex.getMessage());
106 }
107
108 @Test
109 public void createRepositoryTest() {
110 var date = new Date();
111 var input = new SemanticRepositoryIO() {
112 {
113 setEndpoint("http://test.org");
114 setName("Name");
115 setType(SemanticRepositoryType.SPARQL);
116 }
117 };
118 var toCreate = new SemanticRepository() {
119 {
120 setCreatedAt(date);
121 setCreatedBy(user);
122 setEndpoint("http://test.org");
123 setName("Name");
124 setType(SemanticRepositoryType.SPARQL);
125 }
126 };
127 var expected = new SemanticRepository() {
128 {
129 setId(1L);
130 setCreatedAt(date);
131 setCreatedBy(user);
132 setEndpoint("http://test.org");
133 setName("Name");
134 setType(SemanticRepositoryType.SPARQL);
135 }
136 };
137
138 when(userService.getCurrentUser()).thenReturn(user);
139 when(dateHelper.getDate()).thenReturn(date);
140 when(semanticRepositoryConnector.healthCheck()).thenReturn(true);
141 when(semanticRepositoryDAO.createOrUpdate(toCreate)).thenReturn(expected);
142
143 var actual = service.createRepository(input);
144 assertEquals(expected, actual);
145 }
146
147 @Test
148 public void createRepositoryTest_malformedUrl() {
149 var user = new User("bob");
150 var date = new Date();
151 var input = new SemanticRepositoryIO() {
152 {
153 setEndpoint("wrong");
154 setName("Name");
155 setType(SemanticRepositoryType.SPARQL);
156 }
157 };
158
159 when(dateHelper.getDate()).thenReturn(date);
160 when(userService.getCurrentUser()).thenReturn(user);
161
162 assertThrows(InvalidBodyException.class, () -> service.createRepository(input));
163 }
164
165 @Test
166 public void createRepositoryTest_healthCheckFailed() {
167 var user = new User("bob");
168 var date = new Date();
169 var input = new SemanticRepositoryIO() {
170 {
171 setEndpoint("http://test.org");
172 setName("Name");
173 setType(SemanticRepositoryType.SPARQL);
174 }
175 };
176
177 when(userService.getCurrentUser()).thenReturn(user);
178 when(dateHelper.getDate()).thenReturn(date);
179 when(semanticRepositoryConnector.healthCheck()).thenReturn(false);
180
181 assertThrows(InvalidBodyException.class, () -> service.createRepository(input));
182 }
183
184 @Test
185 public void deleteRepositoryTest() {
186 var user = new User("bob");
187 var date = new Date();
188 var repository = new SemanticRepository(1L);
189
190 var expected = new SemanticRepository(1L);
191 expected.setDeleted(true);
192 expected.setUpdatedBy(user);
193 expected.setUpdatedAt(date);
194
195 when(userService.getCurrentUser()).thenReturn(user);
196 when(dateHelper.getDate()).thenReturn(date);
197 when(semanticRepositoryDAO.findByNeo4jId(1L)).thenReturn(repository);
198
199 assertDoesNotThrow(() -> service.deleteRepository(1L));
200 verify(semanticRepositoryDAO).createOrUpdate(expected);
201 }
202
203 @Test
204 public void deleteRepositoryTest_repositoryIsNull() {
205 var user = new User("bob");
206 var date = new Date();
207
208 when(userService.getCurrentUser()).thenReturn(user);
209 when(dateHelper.getDate()).thenReturn(date);
210 when(semanticRepositoryDAO.findByNeo4jId(1L)).thenReturn(null);
211
212 assertThrows(InvalidPathException.class, () -> service.deleteRepository(1L));
213 }
214 }