1 package de.dlr.shepard.context.semantic.services;
2
3 import static org.junit.jupiter.api.Assertions.assertEquals;
4 import static org.junit.jupiter.api.Assertions.assertThrows;
5
6 import de.dlr.shepard.auth.security.AuthenticationContext;
7 import de.dlr.shepard.auth.security.JWTPrincipal;
8 import de.dlr.shepard.auth.users.entities.User;
9 import de.dlr.shepard.auth.users.services.UserService;
10 import de.dlr.shepard.common.exceptions.InvalidBodyException;
11 import de.dlr.shepard.common.exceptions.InvalidPathException;
12 import de.dlr.shepard.common.util.QueryParamHelper;
13 import de.dlr.shepard.context.collection.services.CollectionService;
14 import de.dlr.shepard.context.collection.services.DataObjectService;
15 import de.dlr.shepard.context.references.dataobject.services.CollectionReferenceService;
16 import de.dlr.shepard.context.references.dataobject.services.DataObjectReferenceService;
17 import de.dlr.shepard.context.references.file.services.FileReferenceService;
18 import de.dlr.shepard.context.references.structureddata.services.StructuredDataReferenceService;
19 import de.dlr.shepard.context.references.timeseriesreference.services.TimeseriesReferenceService;
20 import de.dlr.shepard.context.semantic.SemanticRepositoryType;
21 import de.dlr.shepard.context.semantic.entities.SemanticRepository;
22 import de.dlr.shepard.context.semantic.io.SemanticRepositoryIO;
23 import de.dlr.shepard.context.version.daos.VersionDAO;
24 import de.dlr.shepard.context.version.services.VersionService;
25 import de.dlr.shepard.data.file.services.FileContainerService;
26 import de.dlr.shepard.data.structureddata.services.StructuredDataContainerService;
27 import de.dlr.shepard.data.structureddata.services.StructuredDataService;
28 import de.dlr.shepard.data.timeseries.services.TimeseriesContainerService;
29 import de.dlr.shepard.data.timeseries.services.TimeseriesService;
30 import de.dlr.shepard.integrationtests.WireMockResource;
31 import io.quarkus.test.common.WithTestResource;
32 import io.quarkus.test.junit.QuarkusTest;
33 import jakarta.inject.Inject;
34 import jakarta.transaction.Transactional;
35 import java.util.List;
36 import org.junit.jupiter.api.BeforeEach;
37 import org.junit.jupiter.api.Test;
38
39 @QuarkusTest
40 @WithTestResource(WireMockResource.class)
41 public class SemanticRepositoryServiceQuarkusTest {
42
43 @Inject
44 CollectionService collectionService;
45
46 @Inject
47 SemanticRepositoryService semanticRepositoryService;
48
49 @Inject
50 UserService userService;
51
52 @Inject
53 AuthenticationContext authenticationContext;
54
55 @Inject
56 TimeseriesService timeseriesService;
57
58 @Inject
59 StructuredDataContainerService structuredDataContainerService;
60
61 @Inject
62 FileContainerService fileContainerService;
63
64 @Inject
65 FileReferenceService fileReferenceService;
66
67 @Inject
68 VersionDAO versionDAO;
69
70 @Inject
71 TimeseriesReferenceService timeseriesReferenceService;
72
73 @Inject
74 TimeseriesContainerService timeseriesContainerService;
75
76 @Inject
77 StructuredDataService structuredDataService;
78
79 @Inject
80 StructuredDataReferenceService structuredDataReferenceService;
81
82 @Inject
83 DataObjectService dataObjectService;
84
85 @Inject
86 DataObjectReferenceService dataObjectReferenceService;
87
88 @Inject
89 VersionService versionService;
90
91 @Inject
92 CollectionReferenceService collectionReferenceService;
93
94 @Inject
95 SemanticRepositoryService semanticRepositoryReferenceService;
96
97 private String username = "user";
98 private User user;
99 private SemanticRepository rep1;
100 private SemanticRepository rep2;
101 private SemanticRepository repToDelete;
102
103 @BeforeEach
104 public void setUp() {
105 if (user == null) {
106 User user = new User(username);
107 userService.createOrUpdateUser(user);
108 authenticationContext.setPrincipal(new JWTPrincipal(username, "key"));
109 }
110 SemanticRepositoryIO repToDeleteIO = new SemanticRepositoryIO();
111 repToDeleteIO.setName("repToDelete" + System.currentTimeMillis());
112 repToDeleteIO.setType(SemanticRepositoryType.SPARQL);
113 repToDeleteIO.setEndpoint(WireMockResource.getWireMockServerURlWithPath("/sparql"));
114 repToDelete = semanticRepositoryService.createRepository(repToDeleteIO);
115 SemanticRepositoryIO rep2ToCreate = new SemanticRepositoryIO();
116 rep2ToCreate.setName("rep2" + System.currentTimeMillis());
117 rep2ToCreate.setType(SemanticRepositoryType.SPARQL);
118 rep2ToCreate.setEndpoint(WireMockResource.getWireMockServerURlWithPath("/sparql"));
119 rep2 = semanticRepositoryService.createRepository(rep2ToCreate);
120 SemanticRepositoryIO rep1ToCreate = new SemanticRepositoryIO();
121 rep1ToCreate.setName("rep1" + System.currentTimeMillis());
122 rep1ToCreate.setType(SemanticRepositoryType.SPARQL);
123 rep1ToCreate.setEndpoint(WireMockResource.getWireMockServerURlWithPath("/sparql"));
124 rep1 = semanticRepositoryService.createRepository(rep1ToCreate);
125 }
126
127 @Test
128 @Transactional
129 public void getAllRepositoriesTest() {
130 QueryParamHelper params = new QueryParamHelper();
131 List<SemanticRepository> allRepositories = semanticRepositoryService.getAllRepositories(params);
132 assertEquals(true, allRepositories.contains(rep1));
133 assertEquals(true, allRepositories.contains(rep2));
134 }
135
136 @Test
137 @Transactional
138 public void getRepositoryByName() {
139 QueryParamHelper params = new QueryParamHelper();
140 params = params.withName(rep1.getName());
141 List<SemanticRepository> allRepositories = semanticRepositoryService.getAllRepositories(params);
142 assertEquals(1, allRepositories.size());
143 assertEquals(true, allRepositories.contains(rep1));
144 }
145
146 @Test
147 @Transactional
148 public void getRepositoriesWithPagination() {
149 QueryParamHelper params0 = new QueryParamHelper();
150 params0 = params0.withName(rep1.getName());
151 params0 = params0.withPageAndSize(2, 2);
152 QueryParamHelper params2 = new QueryParamHelper();
153 params2 = params2.withPageAndSize(0, 2);
154 QueryParamHelper params1 = new QueryParamHelper();
155 params1 = params1.withPageAndSize(1, 1);
156 List<SemanticRepository> allRepositories = semanticRepositoryService.getAllRepositories(params1);
157 assertEquals(1, allRepositories.size());
158 allRepositories = semanticRepositoryService.getAllRepositories(params2);
159 assertEquals(2, allRepositories.size());
160 allRepositories = semanticRepositoryService.getAllRepositories(params0);
161 assertEquals(0, allRepositories.size());
162 }
163
164 @Test
165 @Transactional
166 public void getRepositoryById() {
167 assertEquals(rep1, semanticRepositoryService.getRepository(rep1.getId()));
168 }
169
170 @Test
171 @Transactional
172 public void testDeleteRepository() {
173 assertEquals(repToDelete, semanticRepositoryService.getRepository(repToDelete.getId()));
174 semanticRepositoryService.deleteRepository(repToDelete.getId());
175 InvalidPathException ex = assertThrows(InvalidPathException.class, () ->
176 semanticRepositoryService.getRepository(repToDelete.getId())
177 );
178 assertEquals(
179 "ID ERROR - Semantic Repository with id " + repToDelete.getId() + " is null or deleted",
180 ex.getMessage()
181 );
182 }
183
184 @Test
185 @Transactional
186 public void createRepositoryMalformedURL() {
187 SemanticRepositoryIO repMalformedURL = new SemanticRepositoryIO();
188 repMalformedURL.setName("repMalformedURL");
189 repMalformedURL.setType(SemanticRepositoryType.SPARQL);
190 repMalformedURL.setEndpoint("noEndpoint");
191 InvalidBodyException ex = assertThrows(InvalidBodyException.class, () ->
192 semanticRepositoryService.createRepository(repMalformedURL)
193 );
194 assertEquals("Invalid endpoint", ex.getMessage());
195 }
196
197 @Test
198 @Transactional
199 public void createRepositoryHealthCheckFailed() {
200 SemanticRepositoryIO repMalformedURL = new SemanticRepositoryIO();
201 repMalformedURL.setName("repMalformedURL");
202 repMalformedURL.setType(SemanticRepositoryType.SPARQL);
203 repMalformedURL.setEndpoint("http://test.org");
204 Exception ex = assertThrows(Exception.class, () -> semanticRepositoryService.createRepository(repMalformedURL));
205 }
206 }