diff --git a/pluto-server/pom.xml b/pluto-server/pom.xml
index 71b37a75738b3be4d24839e97c828b3c71f46b26..a19c33857e92480145782ed67f6f27156140ac0a 100644
--- a/pluto-server/pom.xml
+++ b/pluto-server/pom.xml
@@ -185,15 +185,13 @@
<version>1.15.3</version>
<scope>test</scope>
</dependency>
-
-<<<<<<< HEAD
<dependency>
<groupId>org.testcontainers</groupId>
<artifactId>solr</artifactId>
<version>1.16.2</version>
<scope>test</scope>
</dependency>
-=======
+
<!-- mongock -->
<dependency>
<groupId>io.mongock</groupId>
@@ -205,7 +203,6 @@
<artifactId>mongodb-springdata-v3-driver</artifactId>
<version>${mongock.version}</version>
</dependency>
->>>>>>> refs/remotes/origin/master
</dependencies>
<build>
diff --git a/pluto-server/src/main/java/de/itvsh/ozg/pluto/BeansConfig.java b/pluto-server/src/main/java/de/itvsh/ozg/pluto/BeansConfig.java
index ca2edf0a0bb7c556734e7e9968bf5e1c8ef8e948..845b288a6c369e219b96daec5a673679afa2a77b 100644
--- a/pluto-server/src/main/java/de/itvsh/ozg/pluto/BeansConfig.java
+++ b/pluto-server/src/main/java/de/itvsh/ozg/pluto/BeansConfig.java
@@ -1,9 +1,15 @@
package de.itvsh.ozg.pluto;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.solr.client.solrj.SolrClient;
+import org.apache.solr.client.solrj.impl.CloudHttp2SolrClient;
+import org.apache.solr.client.solrj.impl.HttpSolrClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.view.freemarker.FreeMarkerConfigurer;
+import de.itvsh.ozg.pluto.common.solr.SolrProperties;
+
@Configuration
public class BeansConfig {
@@ -14,4 +20,19 @@ public class BeansConfig {
freeMarkerConfigurer.setDefaultEncoding("UTF-8");
return freeMarkerConfigurer;
}
+
+ @Bean
+ public SolrClient getSolrClient(SolrProperties properties) {
+ SolrClient client = null;
+ if (CollectionUtils.isNotEmpty(properties.getHosts()) && properties.getHosts().size() > 1) {
+ client = new CloudHttp2SolrClient.Builder(properties.getHosts()).build();
+ } else if (CollectionUtils.isNotEmpty(properties.getHosts())) {
+ client = new HttpSolrClient.Builder(properties.getHosts().get(0))
+ .withConnectionTimeout(properties.getConnectionTimeout())
+ .withSocketTimeout(properties.getSocketTimeout())
+ .build();
+ }
+
+ return client;
+ }
}
diff --git a/pluto-server/src/main/java/de/itvsh/ozg/pluto/PlutoServerApplication.java b/pluto-server/src/main/java/de/itvsh/ozg/pluto/PlutoServerApplication.java
index 1965aee359f201a9c6d58c2172a498652782c61a..77094c8371175c6bc0e073ae69d44156617284db 100644
--- a/pluto-server/src/main/java/de/itvsh/ozg/pluto/PlutoServerApplication.java
+++ b/pluto-server/src/main/java/de/itvsh/ozg/pluto/PlutoServerApplication.java
@@ -4,6 +4,7 @@ import java.util.TimeZone;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.context.properties.ConfigurationPropertiesScan;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.EnableScheduling;
@@ -15,6 +16,7 @@ import io.mongock.runner.springboot.EnableMongock;
@EnableScheduling
@EnableAspectJAutoProxy(proxyTargetClass = true)
@EnableMongock
+@ConfigurationPropertiesScan("de.itvsh.ozg.pluto.common.*")
public class PlutoServerApplication {
public static void main(String[] args) {
diff --git a/pluto-server/src/main/java/de/itvsh/ozg/pluto/common/solr/SolrEventListener.java b/pluto-server/src/main/java/de/itvsh/ozg/pluto/common/solr/SolrEventListener.java
index 615dec76db2f94f3c8ab2611053bedb0ec39616b..5d86f660fd42e110b22308ec7c8ca6692c795ca5 100644
--- a/pluto-server/src/main/java/de/itvsh/ozg/pluto/common/solr/SolrEventListener.java
+++ b/pluto-server/src/main/java/de/itvsh/ozg/pluto/common/solr/SolrEventListener.java
@@ -2,12 +2,11 @@ package de.itvsh.ozg.pluto.common.solr;
import java.util.Optional;
-import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;
-import de.itvsh.ozg.mail.common.errorhandling.TechnicalException;
import de.itvsh.ozg.pluto.command.Command;
import de.itvsh.ozg.pluto.command.CommandService;
import de.itvsh.ozg.pluto.vorgang.StatusChangedEvent;
@@ -17,6 +16,7 @@ import de.itvsh.ozg.pluto.vorgang.VorgangCreatedEvent;
import de.itvsh.ozg.pluto.vorgang.VorgangService;
@Component
+@ConditionalOnBean(SolrService.class)
public class SolrEventListener {
@Autowired
private SolrService solrService;
@@ -29,16 +29,12 @@ public class SolrEventListener {
@EventListener
public void onNewVorgang(VorgangCreatedEvent event) {
- solrService.addVorgang(VorgangMapper.toSolrInputDocument(event.getVorgang()));
+ solrService.addVorgang(SolrVorgangMapper.toSolrInputDocument(event.getVorgang()));
}
@EventListener
public void onVorgangAssigned(VorgangAssignedEvent event) {
- if (event.getSource() instanceof Command command) {
- updateVorgang(command);
- } else {
- throw new TechnicalException("Event has invalid source type. Expected type Command, but was " + event.getClass());
- }
+ updateVorgang((Command) event.getSource());
}
@EventListener
@@ -47,17 +43,12 @@ public class SolrEventListener {
}
void updateVorgang(Command command) {
- String vorgangId = command.getVorgangId();
- if (StringUtils.isNotEmpty(vorgangId)) {
- Vorgang vorgang = vorgangService.getById(vorgangId);
- solrService.updateVorgang(VorgangMapper.toSolrInputDocument(vorgang));
- }
-
+ Vorgang vorgang = vorgangService.getById(command.getVorgangId());
+ solrService.updateVorgang(SolrVorgangMapper.toSolrInputDocument(vorgang));
}
private void updateVorgangById(String commandId) {
Optional<Command> command = commandService.findCommand(commandId);
command.ifPresent(this::updateVorgang);
}
-
}
diff --git a/pluto-server/src/main/java/de/itvsh/ozg/pluto/common/solr/SolrProperties.java b/pluto-server/src/main/java/de/itvsh/ozg/pluto/common/solr/SolrProperties.java
new file mode 100644
index 0000000000000000000000000000000000000000..635896911478c25922e4d94c55d4277b3b344597
--- /dev/null
+++ b/pluto-server/src/main/java/de/itvsh/ozg/pluto/common/solr/SolrProperties.java
@@ -0,0 +1,18 @@
+package de.itvsh.ozg.pluto.common.solr;
+
+import java.util.List;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+@ConfigurationProperties(prefix = "kop.solr")
+public class SolrProperties {
+ private List<String> hosts;
+ private String collection;
+ private int socketTimeout = 10000;
+ private int connectionTimeout = 5000;
+}
diff --git a/pluto-server/src/main/java/de/itvsh/ozg/pluto/common/solr/SolrService.java b/pluto-server/src/main/java/de/itvsh/ozg/pluto/common/solr/SolrService.java
index b12890111f30c74a07f5add87f81ef0cb750fdcd..ef2e44e5f0a879433b76698326aa71dfcb2f254a 100644
--- a/pluto-server/src/main/java/de/itvsh/ozg/pluto/common/solr/SolrService.java
+++ b/pluto-server/src/main/java/de/itvsh/ozg/pluto/common/solr/SolrService.java
@@ -1,93 +1,72 @@
package de.itvsh.ozg.pluto.common.solr;
import java.io.IOException;
-import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import org.apache.solr.client.solrj.SolrClient;
import org.apache.solr.client.solrj.SolrServerException;
-import org.apache.solr.client.solrj.impl.CloudHttp2SolrClient;
-import org.apache.solr.client.solrj.impl.HttpSolrClient;
import org.apache.solr.client.solrj.response.QueryResponse;
import org.apache.solr.common.SolrDocumentList;
import org.apache.solr.common.SolrInputDocument;
import org.apache.solr.common.params.MapSolrParams;
-import org.springframework.beans.factory.annotation.Value;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.stereotype.Service;
-import io.micrometer.core.instrument.util.StringUtils;
import lombok.extern.java.Log;
@Service
@Log
+@ConditionalOnBean(SolrClient.class)
public class SolrService {
+ public static final String SOLR_QUERY = "q";
+ public static final String SOLR_FIELD = "fl";
+ public static final String SOLR_SORT = "sort";
+ public static final String SOLR_ID = "id";
+ public static final String SOLR_SORT_ID_ASC = "id asc";
- @Value("${pluto.solr.hosts}")
- private String solrHosts;
+ @Autowired
+ private SolrProperties properties;
- @Value("${pluto.solr.collection}")
- private String solrCollection;
-
- @Value("${pluto.solr.timeout.connection:5000}")
- private int connectionTimeout;
-
- @Value("${pluto.solr.timeout.socket:10000}")
- private int socketTimeout;
-
- private SolrClient solrClient;
+ @Autowired
+ private SolrClient client;
public void addVorgang(SolrInputDocument doc) {
- SolrClient client = getSolrClient();
try {
- if (client != null) {
- client.add(solrCollection, doc);
- client.commit(solrCollection);
- }
+ saveToIndex(doc);
} catch (IOException | SolrServerException e) {
LOG.log(Level.WARNING, "Error adding document to index", e);
}
}
public void updateVorgang(SolrInputDocument doc) {
- SolrClient client = getSolrClient();
try {
- if (client != null) {
- final Map<String, String> queryParamMap = new HashMap<>();
- queryParamMap.put("q", "aktenzeichen:" + doc.getFieldValue("aktenzeichen"));
- queryParamMap.put("fl", "id");
- queryParamMap.put("sort", "id asc");
- MapSolrParams queryParams = new MapSolrParams(queryParamMap);
- final QueryResponse response = client.query("test", queryParams);
- final SolrDocumentList documents = response.getResults();
+ SolrDocumentList documents = loadSolrDocuments(doc);
+ doc.addField(SOLR_ID, documents.get(0).getFieldValue(SOLR_ID));
- doc.addField("id", documents.get(0).getFieldValue("id"));
- client.add(solrCollection, doc);
- client.commit(solrCollection);
- }
+ saveToIndex(doc);
} catch (IOException | SolrServerException e) {
LOG.log(Level.WARNING, "Error updating document to index", e);
}
}
- SolrClient getSolrClient() {
- SolrClient client = null;
- if (solrClient != null) {
- client = solrClient;
- } else {
- if (StringUtils.isNotEmpty(solrHosts) && solrHosts.contains(";")) {
- String[] hosts = solrHosts.split(";");
- client = new CloudHttp2SolrClient.Builder(Arrays.asList(hosts)).build();
- } else if (StringUtils.isNotEmpty(solrHosts)) {
- client = new HttpSolrClient.Builder(solrHosts).withConnectionTimeout(connectionTimeout).withSocketTimeout(socketTimeout).build();
- } else {
- LOG.info("pluto.solr.hosts ist nocht nicht konfiguriert, Vorgänge werden nicht zum Solr hinzugefügt");
- }
+ private SolrDocumentList loadSolrDocuments(SolrInputDocument doc) throws SolrServerException, IOException {
+ QueryResponse response = client.query(properties.getCollection(), createQueryParams(doc));
+ return response.getResults();
+ }
- solrClient = client;
- }
+ private MapSolrParams createQueryParams(SolrInputDocument doc) {
+ final Map<String, String> queryParamMap = new HashMap<>();
+ queryParamMap.put(SOLR_QUERY, SolrVorgangMapper.AKTENZEICHEN + ":" + doc.getFieldValue(SolrVorgangMapper.AKTENZEICHEN));
+ queryParamMap.put(SOLR_FIELD, SOLR_ID);
+ queryParamMap.put(SOLR_SORT, SOLR_SORT_ID_ASC);
+ return new MapSolrParams(queryParamMap);
+ }
- return client;
+ private void saveToIndex(SolrInputDocument doc) throws SolrServerException, IOException {
+ client.add(properties.getCollection(), doc);
+ client.commit(properties.getCollection());
}
}
diff --git a/pluto-server/src/main/java/de/itvsh/ozg/pluto/common/solr/SolrVorgangMapper.java b/pluto-server/src/main/java/de/itvsh/ozg/pluto/common/solr/SolrVorgangMapper.java
new file mode 100644
index 0000000000000000000000000000000000000000..93e2f133640236d8a9d316b6813144b78fe04439
--- /dev/null
+++ b/pluto-server/src/main/java/de/itvsh/ozg/pluto/common/solr/SolrVorgangMapper.java
@@ -0,0 +1,46 @@
+package de.itvsh.ozg.pluto.common.solr;
+
+import org.apache.solr.common.SolrInputDocument;
+
+import de.itvsh.ozg.pluto.vorgang.Eingang;
+import de.itvsh.ozg.pluto.vorgang.Vorgang;
+import lombok.experimental.UtilityClass;
+
+@UtilityClass
+class SolrVorgangMapper {
+ public static final String NAME = "name";
+ public static final String AKTENZEICHEN = "aktenzeichen";
+ public static final String ASSIGNED_TO = "assignedTo";
+ public static final String STATUS = "status";
+ public static final String CREATED_AT = "createdAt";
+ public static final String ORGANISATIONSEINHEITEN_ID = "eingang_zustaendigeStelle_organisationseinheitenId";
+ public static final String ANTRAGSTELLER_VORNAME = "antragsteller_vorname";
+ public static final String ANTRAGSTELLER_NACHNAME = "antragsteller_nachname";
+ public static final String VORGANG_ID = "vorgangId";
+
+ static SolrInputDocument toSolrInputDocument(Vorgang vorgang) {
+ SolrInputDocument doc = new SolrInputDocument();
+ doc.setField(NAME, vorgang.getName());
+ doc.setField(AKTENZEICHEN, vorgang.getAktenzeichen());
+ doc.setField(ASSIGNED_TO, vorgang.getAssignedTo());
+ doc.setField(STATUS, vorgang.getStatus().name());
+ doc.setField(CREATED_AT, vorgang.getCreatedAt());
+
+ setEingang(vorgang, doc);
+
+ return doc;
+ }
+
+ private static void setEingang(Vorgang vorgang, SolrInputDocument doc) {
+ if (vorgang.getEingangs() != null && !vorgang.getEingangs().isEmpty()) {
+ Eingang eingang = vorgang.getEingangs().get(0);
+ if (eingang.getZustaendigeStelle() != null) {
+ doc.setField(ORGANISATIONSEINHEITEN_ID, eingang.getZustaendigeStelle().getOrganisationseinheitenId());
+ }
+ if (eingang.getAntragsteller() != null) {
+ doc.setField(ANTRAGSTELLER_VORNAME, eingang.getAntragsteller().getVorname());
+ doc.setField(ANTRAGSTELLER_NACHNAME, eingang.getAntragsteller().getNachname());
+ }
+ }
+ }
+}
diff --git a/pluto-server/src/main/java/de/itvsh/ozg/pluto/common/solr/VorgangMapper.java b/pluto-server/src/main/java/de/itvsh/ozg/pluto/common/solr/VorgangMapper.java
deleted file mode 100644
index ac766f10db099b4bb79d7b095d2af68f298793d6..0000000000000000000000000000000000000000
--- a/pluto-server/src/main/java/de/itvsh/ozg/pluto/common/solr/VorgangMapper.java
+++ /dev/null
@@ -1,33 +0,0 @@
-package de.itvsh.ozg.pluto.common.solr;
-
-import org.apache.solr.common.SolrInputDocument;
-
-import de.itvsh.ozg.pluto.vorgang.Eingang;
-import de.itvsh.ozg.pluto.vorgang.Vorgang;
-
-class VorgangMapper {
- private VorgangMapper() {
- // Utility class
- }
-
- static SolrInputDocument toSolrInputDocument(Vorgang vorgang) {
- SolrInputDocument doc = new SolrInputDocument();
- doc.setField("name", vorgang.getName());
- doc.setField("aktenzeichen", vorgang.getAktenzeichen());
- doc.setField("assignedTo", vorgang.getAssignedTo());
- doc.setField("status", vorgang.getStatus().name());
- doc.setField("createdAt", vorgang.getCreatedAt());
- if (vorgang.getEingangs() != null && !vorgang.getEingangs().isEmpty()) {
- Eingang eingang = vorgang.getEingangs().get(0);
- if (eingang.getZustaendigeStelle() != null) {
- doc.setField("eingang_zustaendigeStelle_organisationseinheitenId", eingang.getZustaendigeStelle().getOrganisationseinheitenId());
- }
- if (eingang.getAntragsteller() != null) {
- doc.setField("antragsteller_vorname", eingang.getAntragsteller().getVorname());
- doc.setField("antragsteller_nachname", eingang.getAntragsteller().getNachname());
- }
- }
-
- return doc;
- }
-}
diff --git a/pluto-server/src/main/resources/application-local.yml b/pluto-server/src/main/resources/application-local.yml
index a30c3c628dac90d325b9fd60c016807b4b0f739d..bc022ab7c07bf53f32754e42db28938351a678cb 100644
--- a/pluto-server/src/main/resources/application-local.yml
+++ b/pluto-server/src/main/resources/application-local.yml
@@ -32,10 +32,7 @@ spring:
pluto:
redirect:
- mail-from: ea@ozg-sh.de
- solr:
- hosts: http://localhost:8983/solr
- collection: kop
+ mail-from: ea@ozg-sh.de
kop:
osi:
@@ -50,5 +47,9 @@ kop:
vorgang:
filter:
defaultBehaviour: SHOW_ALL
+ solr:
+ hosts:
+ - http://localhost:8983/solr
+ collection: kop
aktenzeichen: de.itvsh.ozg.pluto.vorgang.AktenzeichenProviderEA
\ No newline at end of file
diff --git a/pluto-server/src/main/resources/application.yml b/pluto-server/src/main/resources/application.yml
index 65122cf1c8fa6c131b0f72eff5419806d6cd98c3..6bff381877c216ce881c1b6982dc950eb43f1d49 100644
--- a/pluto-server/src/main/resources/application.yml
+++ b/pluto-server/src/main/resources/application.yml
@@ -24,9 +24,6 @@ pluto:
production: false
forwarding:
reply-to: EA-Poststelle@itvsh.de
- solr:
- hosts:
- collection: kop
management:
server:
diff --git a/pluto-server/src/test/java/de/itvsh/ozg/pluto/common/solr/SolrITCase.java b/pluto-server/src/test/java/de/itvsh/ozg/pluto/common/solr/SolrITCase.java
new file mode 100644
index 0000000000000000000000000000000000000000..4c3a5f6cbcd02c185eee1cb58b2603b68bf21c92
--- /dev/null
+++ b/pluto-server/src/test/java/de/itvsh/ozg/pluto/common/solr/SolrITCase.java
@@ -0,0 +1,24 @@
+package de.itvsh.ozg.pluto.common.solr;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.test.context.ContextConfiguration;
+
+import de.itvsh.kop.common.test.DataITCase;
+import de.itvsh.kop.common.test.DbInitializer;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+@Inherited
+
+@DataITCase
+@ContextConfiguration(initializers = { SolrInitializer.class, DbInitializer.class })
+@ActiveProfiles({ "itcase", "with_db", "with_solr" })
+public @interface SolrITCase {
+
+}
diff --git a/pluto-server/src/test/java/de/itvsh/ozg/pluto/common/solr/SolrInitializer.java b/pluto-server/src/test/java/de/itvsh/ozg/pluto/common/solr/SolrInitializer.java
new file mode 100644
index 0000000000000000000000000000000000000000..39827af92be6f3c1bd4915e00c20525fd84ba968
--- /dev/null
+++ b/pluto-server/src/test/java/de/itvsh/ozg/pluto/common/solr/SolrInitializer.java
@@ -0,0 +1,23 @@
+package de.itvsh.ozg.pluto.common.solr;
+
+import org.springframework.boot.test.util.TestPropertyValues;
+import org.springframework.context.ApplicationContextInitializer;
+import org.springframework.context.ConfigurableApplicationContext;
+import org.testcontainers.containers.SolrContainer;
+import org.testcontainers.utility.DockerImageName;
+
+public class SolrInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
+
+ @Override
+ public void initialize(ConfigurableApplicationContext applicationContext) {
+ SolrContainer solrContainer = new SolrContainer(DockerImageName.parse("solr").withTag("8.11"));
+ solrContainer.start();
+ Integer port = solrContainer.getFirstMappedPort();
+
+ TestPropertyValues.of(
+ "kop.solr.hosts[0]=http://" + solrContainer.getHost() + ":" + port + "/solr",
+ "kop.solr.collection=test",
+ "kop.solr.port=" + port).applyTo(applicationContext.getEnvironment());
+
+ }
+}
diff --git a/pluto-server/src/test/java/de/itvsh/ozg/pluto/common/solr/SolrInputDocumentFactory.java b/pluto-server/src/test/java/de/itvsh/ozg/pluto/common/solr/SolrInputDocumentFactory.java
deleted file mode 100644
index 2c3575c2d119225720303ce3ed3a8fececa03d59..0000000000000000000000000000000000000000
--- a/pluto-server/src/test/java/de/itvsh/ozg/pluto/common/solr/SolrInputDocumentFactory.java
+++ /dev/null
@@ -1,26 +0,0 @@
-package de.itvsh.ozg.pluto.common.solr;
-
-import java.time.ZonedDateTime;
-
-import org.apache.solr.common.SolrInputDocument;
-
-class SolrInputDocumentFactory {
- private SolrInputDocumentFactory() {
-
- }
-
- static SolrInputDocument create() {
- ZonedDateTime dateTime = ZonedDateTime.now();
- SolrInputDocument vorgang = new SolrInputDocument();
- vorgang.addField("aktenzeichen", "aktenzeichen");
- vorgang.addField("assignedTo", "sabine");
- vorgang.addField("createdAt", dateTime.toString());
- vorgang.addField("name", "name");
- vorgang.addField("status", "NEU");
- vorgang.addField("eingang_zustaendigeStelle_organisationseinheitenId", "org_einhait_id");
- vorgang.addField("antragsteller_vorname", "Max");
- vorgang.addField("antragsteller_nachname", "Mueller");
-
- return vorgang;
- }
-}
diff --git a/pluto-server/src/test/java/de/itvsh/ozg/pluto/common/solr/SolrInputDocumentTestFactory.java b/pluto-server/src/test/java/de/itvsh/ozg/pluto/common/solr/SolrInputDocumentTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..5c4a117c7edff77961f75e472df0a870b2542ac8
--- /dev/null
+++ b/pluto-server/src/test/java/de/itvsh/ozg/pluto/common/solr/SolrInputDocumentTestFactory.java
@@ -0,0 +1,33 @@
+package de.itvsh.ozg.pluto.common.solr;
+
+import java.time.ZonedDateTime;
+
+import org.apache.solr.common.SolrInputDocument;
+
+import lombok.experimental.UtilityClass;
+
+@UtilityClass
+class SolrInputDocumentTestFactory {
+ public static final String AKTENZEICHEN = "65124217325";
+ public static final String ASSIGNED_TO = "43434-734747";
+ public static final String CREATED_AT = ZonedDateTime.now().toString();
+ public static final String NAME = "testname";
+ public static final String STATUS = "NEU";
+ public static final String ZUSTAENDIGESTELLE_ORGANISATIONSEINHEITEN_ID = "zus_org_id";
+ public static final String ANTRAGSTELLER_VORNAME = "Max";
+ public static final String ANTRAGSTELLER_NACHNAME = "Mueller";
+
+ static SolrInputDocument create() {
+ SolrInputDocument vorgang = new SolrInputDocument();
+ vorgang.addField(SolrVorgangMapper.AKTENZEICHEN, AKTENZEICHEN);
+ vorgang.addField(SolrVorgangMapper.ASSIGNED_TO, ASSIGNED_TO);
+ vorgang.addField(SolrVorgangMapper.CREATED_AT, CREATED_AT);
+ vorgang.addField(SolrVorgangMapper.NAME, NAME);
+ vorgang.addField(SolrVorgangMapper.STATUS, STATUS);
+ vorgang.addField(SolrVorgangMapper.ORGANISATIONSEINHEITEN_ID, ZUSTAENDIGESTELLE_ORGANISATIONSEINHEITEN_ID);
+ vorgang.addField(SolrVorgangMapper.ANTRAGSTELLER_VORNAME, ANTRAGSTELLER_VORNAME);
+ vorgang.addField(SolrVorgangMapper.ANTRAGSTELLER_NACHNAME, ANTRAGSTELLER_NACHNAME);
+
+ return vorgang;
+ }
+}
diff --git a/pluto-server/src/test/java/de/itvsh/ozg/pluto/common/solr/SolrServerITCase.java b/pluto-server/src/test/java/de/itvsh/ozg/pluto/common/solr/SolrServerITCase.java
index c091765af722167ce05c8107de795d507fb8ee8d..cd227c214123c93c45bedb61f5160f162ac65569 100644
--- a/pluto-server/src/test/java/de/itvsh/ozg/pluto/common/solr/SolrServerITCase.java
+++ b/pluto-server/src/test/java/de/itvsh/ozg/pluto/common/solr/SolrServerITCase.java
@@ -1,6 +1,6 @@
package de.itvsh.ozg.pluto.common.solr;
-import static org.junit.Assert.assertNotNull;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.when;
@@ -23,20 +23,15 @@ import org.apache.solr.common.SolrDocument;
import org.apache.solr.common.SolrDocumentList;
import org.apache.solr.common.SolrInputDocument;
import org.apache.solr.common.params.MapSolrParams;
-import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.data.mongodb.core.MongoOperations;
-import org.springframework.test.util.ReflectionTestUtils;
-import org.testcontainers.containers.SolrContainer;
-import org.testcontainers.utility.DockerImageName;
-import de.itvsh.kop.common.test.DataITCase;
import de.itvsh.ozg.pluto.command.Command;
import de.itvsh.ozg.pluto.command.CommandService;
import de.itvsh.ozg.pluto.vorgang.Eingang;
@@ -47,14 +42,14 @@ import de.itvsh.ozg.pluto.vorgang.Vorgang;
import de.itvsh.ozg.pluto.vorgang.Vorgang.Status;
import de.itvsh.ozg.pluto.vorgang.VorgangService;
-@DataITCase
+@SolrITCase
class SolrServerITCase {
- private static SolrContainer solrContainer;
- static String baseUrl;
-
@Autowired
private SolrService solrService;
+ @Autowired
+ private SolrClient solrClient;
+
@Autowired
private VorgangService vorgangService;
@@ -64,31 +59,31 @@ class SolrServerITCase {
@MockBean
private CommandService commandService;
- SolrInputDocument vorgang;
- String dateTime;
+ @Autowired
+ private SolrProperties solrProperties;
- @BeforeAll
- static void setUpClass() {
- solrContainer = new SolrContainer(DockerImageName.parse("solr").withTag("8.11"));
- solrContainer.start();
+ @Value("${kop.solr.port}")
+ private String solrPort;
- baseUrl = "http://" + solrContainer.getContainerIpAddress() + ":" + solrContainer.getSolrPort() + "/solr";
- System.out.println("Using solr at " + baseUrl);
- }
+ @Value("${kop.solr.collection}")
+ private String collectionName;
+
+ private SolrInputDocument vorgang;
+
+ private String baseUrl;
@BeforeEach
- void setUp() {
+ void init() {
+ baseUrl = solrProperties.getHosts().get(0);
+
Command cmd = Command.builder().id("testid").vorgangId("vorgangId").build();
when(commandService.findCommand("testId")).thenReturn(Optional.of(cmd));
- ReflectionTestUtils.setField(solrService, "solrCollection", "test");
- ReflectionTestUtils.setField(solrService, "solrHosts", baseUrl);
-
- vorgang = SolrInputDocumentFactory.create();
- dateTime = vorgang.get("createdAt").getValue().toString();
+ vorgang = SolrInputDocumentTestFactory.create();
HttpClient httpClient = HttpClient.newHttpClient();
- HttpRequest addRequest = HttpRequest.newBuilder().uri(URI.create(baseUrl + "/admin/collections?action=CREATE&name=test&numShards=1"))
+ HttpRequest addRequest = HttpRequest.newBuilder()
+ .uri(URI.create(baseUrl + "/admin/collections?action=CREATE&name=" + collectionName + "&numShards=1"))
.build();
httpClient.sendAsync(addRequest, BodyHandlers.ofString())
.thenApply(HttpResponse::body)
@@ -103,15 +98,10 @@ class SolrServerITCase {
}
- @AfterAll
- static void stopContainer() {
- solrContainer.stop();
- }
-
@AfterEach
void tearDown() {
HttpClient httpClient = HttpClient.newHttpClient();
- HttpRequest addRequest = HttpRequest.newBuilder().uri(URI.create(baseUrl + "/admin/collections?action=DELETE&name=test"))
+ HttpRequest addRequest = HttpRequest.newBuilder().uri(URI.create(baseUrl + "/admin/collections?action=DELETE&name=" + collectionName))
.build();
httpClient.sendAsync(addRequest, BodyHandlers.ofString())
.thenApply(HttpResponse::body)
@@ -119,21 +109,25 @@ class SolrServerITCase {
}
private SolrDocumentList query(String key, Object value) throws SolrServerException, IOException {
- SolrClient client = solrService.getSolrClient();
- final Map<String, String> queryParamMap = new HashMap<String, String>();
- queryParamMap.put("q", key + ":" + value);
- queryParamMap.put("sort", "id asc");
- MapSolrParams queryParams = new MapSolrParams(queryParamMap);
- final QueryResponse response = client.query("test", queryParams);
- final SolrDocumentList documents = response.getResults();
- return documents;
+ MapSolrParams queryParams = createQueryParams(key, value);
+
+ QueryResponse response = solrClient.query(collectionName, queryParams);
+
+ return response.getResults();
+ }
+
+ private MapSolrParams createQueryParams(String key, Object value) {
+ Map<String, String> queryParamMap = new HashMap<String, String>();
+ queryParamMap.put(SolrService.SOLR_QUERY, key + ":" + value);
+ queryParamMap.put(SolrService.SOLR_SORT, SolrService.SOLR_SORT_ID_ASC);
+ return new MapSolrParams(queryParamMap);
}
private Optional<Vorgang> findVorgangInDbByAktenzeichen(final SolrDocument doc) {
List<Vorgang> vorgangs = mongoOperations.findAll(Vorgang.class);
return vorgangs.stream().filter(v -> {
- String ak = doc.getFirstValue("aktenzeichen").toString();
+ String ak = doc.getFirstValue(SolrVorgangMapper.AKTENZEICHEN).toString();
return v.getAktenzeichen().equals(ak);
}).findFirst();
}
@@ -142,7 +136,7 @@ class SolrServerITCase {
class TestAddVorgang {
@Test
- void addVorgangTest() throws SolrServerException, IOException {
+ void shouldAdd() throws SolrServerException, IOException {
solrService.addVorgang(vorgang);
final SolrDocumentList documents = query("aktenzeichen", vorgang.get("aktenzeichen").getValue());
@@ -150,30 +144,43 @@ class SolrServerITCase {
assertEquals(1, documents.size());
SolrDocument doc = documents.get(0);
- assertEquals("aktenzeichen", String.valueOf(doc.getFirstValue("aktenzeichen")));
- assertEquals("sabine", String.valueOf(doc.getFirstValue("assignedTo")));
- assertEquals(dateTime, String.valueOf(doc.getFirstValue("createdAt")));
- assertEquals("name", String.valueOf(doc.getFirstValue("name")));
- assertEquals("NEU", String.valueOf(doc.getFirstValue("status")));
- assertEquals("org_einhait_id", String.valueOf(doc.getFirstValue("eingang_zustaendigeStelle_organisationseinheitenId")));
- assertEquals("Max", String.valueOf(doc.getFirstValue("antragsteller_vorname")));
- assertEquals("Mueller", String.valueOf(doc.getFirstValue("antragsteller_nachname")));
-
- assertNotNull(doc.get("id"));
+ assertThat(String.valueOf(doc.getFirstValue(SolrVorgangMapper.AKTENZEICHEN)))
+ .isEqualTo(SolrInputDocumentTestFactory.AKTENZEICHEN);
+ assertThat(String.valueOf(doc.getFirstValue(SolrVorgangMapper.ASSIGNED_TO)))
+ .isEqualTo(SolrInputDocumentTestFactory.ASSIGNED_TO);
+ assertThat(String.valueOf(doc.getFirstValue(SolrVorgangMapper.CREATED_AT)))
+ .isEqualTo(SolrInputDocumentTestFactory.CREATED_AT);
+ assertThat(String.valueOf(doc.getFirstValue(SolrVorgangMapper.NAME)))
+ .isEqualTo(SolrInputDocumentTestFactory.NAME);
+ assertThat(String.valueOf(doc.getFirstValue(SolrVorgangMapper.STATUS)))
+ .isEqualTo(SolrInputDocumentTestFactory.STATUS);
+
+ checkEingang(doc);
+
+ assertThat(doc.get("id")).isNotNull();
+ }
+
+ private void checkEingang(SolrDocument doc) {
+ assertThat(String.valueOf(doc.getFirstValue(SolrVorgangMapper.ORGANISATIONSEINHEITEN_ID)))
+ .isEqualTo(SolrInputDocumentTestFactory.ZUSTAENDIGESTELLE_ORGANISATIONSEINHEITEN_ID);
+ assertThat(String.valueOf(doc.getFirstValue(SolrVorgangMapper.ANTRAGSTELLER_VORNAME)))
+ .isEqualTo(SolrInputDocumentTestFactory.ANTRAGSTELLER_VORNAME);
+ assertThat(String.valueOf(doc.getFirstValue(SolrVorgangMapper.ANTRAGSTELLER_NACHNAME)))
+ .isEqualTo(SolrInputDocumentTestFactory.ANTRAGSTELLER_NACHNAME);
}
@Test
- void addVorgangEventTest() throws SolrServerException, IOException {
+ void shouldAddByEvent() throws SolrServerException, IOException {
Eingang eingang = EingangTestFactory.create();
vorgangService.createVorgang(eingang);
- final SolrDocumentList documents = query("name", eingang.getHeader().getFormName());
+ SolrDocumentList documents = query(SolrInputDocumentTestFactory.NAME, eingang.getHeader().getFormName());
assertEquals(1, documents.size());
SolrDocument doc = documents.get(0);
- assertEquals(eingang.getHeader().getFormName(), String.valueOf(doc.getFirstValue("name")));
- assertEquals("null", String.valueOf(doc.getFirstValue("assignedTo")));
+ assertThat(String.valueOf(doc.getFirstValue(SolrInputDocumentTestFactory.NAME))).isEqualTo(eingang.getHeader().getFormName());
+ assertThat(String.valueOf(doc.getFirstValue(SolrInputDocumentTestFactory.ASSIGNED_TO))).isNull();
}
}
@@ -181,13 +188,13 @@ class SolrServerITCase {
class TestUpdateVorgang {
@Test
- void updateVorgangTest() throws SolrServerException, IOException {
+ void shouldUpdate() throws SolrServerException, IOException {
solrService.addVorgang(vorgang);
- vorgang.setField("assignedTo", "Berta");
+ vorgang.setField(SolrInputDocumentTestFactory.ASSIGNED_TO, "Berta");
solrService.updateVorgang(vorgang);
- final SolrDocumentList documents = query("aktenzeichen", vorgang.get("aktenzeichen").getValue());
+ final SolrDocumentList documents = query(SolrVorgangMapper.AKTENZEICHEN, vorgang.get("aktenzeichen").getValue());
assertEquals(1, documents.size());
SolrDocument doc = documents.get(0);
@@ -197,17 +204,17 @@ class SolrServerITCase {
}
@Test
- void assignVorgangEventTest() throws SolrServerException, IOException {
+ void shouldAssignVorgangByEvent() throws SolrServerException, IOException {
Eingang eingang = EingangTestFactory.create();
vorgangService.createVorgang(eingang);
- SolrDocumentList documents = query("name", eingang.getHeader().getFormName());
+ SolrDocumentList documents = query(SolrVorgangMapper.NAME, eingang.getHeader().getFormName());
assertEquals(1, documents.size());
Optional<Vorgang> vorgang = findVorgangInDbByAktenzeichen(documents.get(0));
vorgang.ifPresent(vor -> {
- Map<String, String> body = Map.of("assignedTo", "Paul");
+ Map<String, String> body = Map.of(SolrVorgangMapper.ASSIGNED_TO, "Paul");
Command command = Command.builder()
.vorgangId(vor.getId())
.relationId(vor.getId())
@@ -228,7 +235,7 @@ class SolrServerITCase {
}
@Test
- void updateVorgangEventTest() throws SolrServerException, IOException {
+ void shouldUpdateByEvent() throws SolrServerException, IOException {
EingangHeader eingangHeader = EingangHeaderTestFactory.createBuilder()
.formName("update_vorgang_doc")
.requestId("update_vorgang_req_id")
diff --git a/pluto-server/src/test/java/de/itvsh/ozg/pluto/common/solr/SolrServiceTest.java b/pluto-server/src/test/java/de/itvsh/ozg/pluto/common/solr/SolrServiceTest.java
index d3323ba2d551737dca0515b90679e5f4b1112f71..5dca8b560d792c3d22beb998721ba88a6507d3a4 100644
--- a/pluto-server/src/test/java/de/itvsh/ozg/pluto/common/solr/SolrServiceTest.java
+++ b/pluto-server/src/test/java/de/itvsh/ozg/pluto/common/solr/SolrServiceTest.java
@@ -1,13 +1,8 @@
package de.itvsh.ozg.pluto.common.solr;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNull;
-import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@@ -15,7 +10,6 @@ import java.io.IOException;
import org.apache.solr.client.solrj.SolrClient;
import org.apache.solr.client.solrj.SolrServerException;
-import org.apache.solr.client.solrj.impl.HttpSolrClient;
import org.apache.solr.client.solrj.response.QueryResponse;
import org.apache.solr.client.solrj.response.UpdateResponse;
import org.apache.solr.common.SolrDocument;
@@ -28,9 +22,9 @@ import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Spy;
-import org.springframework.test.util.ReflectionTestUtils;
class SolrServiceTest {
+ private static final String COLLECTION_NAME = "test";
@Spy
@InjectMocks
@@ -39,107 +33,49 @@ class SolrServiceTest {
@Mock
private SolrClient solrClient;
+ @Mock
+ private SolrProperties properties;
+
private SolrInputDocument vorgang;
@BeforeEach
- void setUp() throws Exception {
- vorgang = SolrInputDocumentFactory.create();
-
- ReflectionTestUtils.setField(solrService, "solrCollection", "test");
+ void init() throws Exception {
+ vorgang = SolrInputDocumentTestFactory.create();
+ when(properties.getCollection()).thenReturn(COLLECTION_NAME);
}
@Nested
class TestAddVorgang {
+ UpdateResponse response = new UpdateResponse();
@Test
- void addVorgang() throws SolrServerException, IOException {
- UpdateResponse response = new UpdateResponse();
- when(solrClient.add("test", vorgang)).thenReturn(response);
+ void shouldAddVorgang() throws SolrServerException, IOException {
+ when(solrClient.add(COLLECTION_NAME, vorgang)).thenReturn(response);
solrService.addVorgang(vorgang);
- verify(solrClient, times(1)).add("test", vorgang);
- verify(solrClient, times(1)).commit("test");
- }
-
- @Test
- void addVorgangNoSolrHostConfigured() throws SolrServerException, IOException {
- ReflectionTestUtils.setField(solrService, "solrClient", null);
- ReflectionTestUtils.setField(solrService, "solrHosts", null);
-
- solrService.addVorgang(vorgang);
-
- verify(solrClient, times(0)).add("test", vorgang);
- verify(solrClient, times(0)).commit("test");
+ verify(solrClient).add(COLLECTION_NAME, vorgang);
+ verify(solrClient).commit(COLLECTION_NAME);
}
}
@Nested
class TestUpdateVorgang {
+ QueryResponse response = mock(QueryResponse.class);
+ SolrDocumentList documents = mock(SolrDocumentList.class);
+ SolrDocument doc = mock(SolrDocument.class);
@Test
- void updateVorgang() throws SolrServerException, IOException {
- QueryResponse response = mock(QueryResponse.class);
- SolrDocumentList documents = mock(SolrDocumentList.class);
- SolrDocument doc = mock(SolrDocument.class);
-
+ void shouldUpdateVorgang() throws SolrServerException, IOException {
when(documents.get(0)).thenReturn(doc);
when(response.getResults()).thenReturn(documents);
when(solrClient.query(anyString(), any(MapSolrParams.class))).thenReturn(response);
solrService.updateVorgang(vorgang);
- verify(solrClient, times(1)).query(anyString(), any(MapSolrParams.class));
- verify(solrClient, times(1)).add("test", vorgang);
- verify(solrClient, times(1)).commit("test");
- }
-
- @Test
- void updateVorgangNoSolrHostConfigured() throws SolrServerException, IOException {
- ReflectionTestUtils.setField(solrService, "solrClient", null);
- ReflectionTestUtils.setField(solrService, "solrHosts", null);
-
- solrService.updateVorgang(vorgang);
-
- verify(solrClient, times(0)).add("test", vorgang);
- verify(solrClient, times(0)).commit("test");
- }
- }
-
- @Nested
- class TestGetSolrClient {
- @Test
- void solrClientLazyLoadingTest() {
- assertEquals(solrClient, solrService.getSolrClient());
- }
-
- @Test
- void initSolrClientTestWhenSolrHostsNotSet() {
- ReflectionTestUtils.setField(solrService, "solrClient", null);
- assertNull(solrService.getSolrClient());
- }
-
- @Test
- void initSolrClientTestWhenOneSolrHostsSet() {
- ReflectionTestUtils.setField(solrService, "solrClient", null);
- ReflectionTestUtils.setField(solrService, "solrHosts", "http://127.0.0.1/solr");
- assertNotNull(solrService.getSolrClient());
- assertEquals(HttpSolrClient.class, solrService.getSolrClient().getClass());
- }
-
- @Test
- void initSolrClientTestWhenMultipleSolrHostsSet() {
- ReflectionTestUtils.setField(solrService, "solrClient", null);
- ReflectionTestUtils.setField(solrService, "solrHosts", "http://127.0.0.1/solr;http://127.0.0.2/solr;http://127.0.0.3/solr");
-
- // The CloudHttp2SolrClient throws an exception when initialized with dummy
- // values,
- // so to test the creation of the solr cloud client we check for the exception.
- RuntimeException thrown = assertThrows(RuntimeException.class, () -> {
- solrService.getSolrClient();
- });
-
- assertNotNull(thrown);
+ verify(solrClient).query(anyString(), any(MapSolrParams.class));
+ verify(solrClient).add(COLLECTION_NAME, vorgang);
+ verify(solrClient).commit(COLLECTION_NAME);
}
}
}
diff --git a/pluto-server/src/test/java/de/itvsh/ozg/pluto/common/solr/SolrVorgangMapperTest.java b/pluto-server/src/test/java/de/itvsh/ozg/pluto/common/solr/SolrVorgangMapperTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..5ecc9cbc16bbc35d3d7c3d3592b840062d89ada7
--- /dev/null
+++ b/pluto-server/src/test/java/de/itvsh/ozg/pluto/common/solr/SolrVorgangMapperTest.java
@@ -0,0 +1,45 @@
+package de.itvsh.ozg.pluto.common.solr;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.time.ZonedDateTime;
+
+import org.apache.solr.common.SolrInputDocument;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import de.itvsh.ozg.pluto.vorgang.Vorgang;
+import de.itvsh.ozg.pluto.vorgang.VorgangTestFactory;
+
+class SolrVorgangMapperTest {
+ Vorgang vorgang;
+ ZonedDateTime dateTime;
+
+ @BeforeEach
+ void setUp() throws Exception {
+ dateTime = ZonedDateTime.now();
+ vorgang = VorgangTestFactory.create();
+ }
+
+ @Test
+ void testToSolrInputDocument() {
+ SolrInputDocument doc = SolrVorgangMapper.toSolrInputDocument(vorgang);
+
+ assertThat(vorgang.getAktenzeichen()).isEqualTo(doc.get(SolrVorgangMapper.AKTENZEICHEN).getValue());
+ assertThat(vorgang.getAssignedTo()).isEqualTo(doc.get(SolrVorgangMapper.ASSIGNED_TO).getValue());
+ assertThat(vorgang.getCreatedAt()).isEqualTo(doc.get(SolrVorgangMapper.CREATED_AT).getValue());
+ assertThat(vorgang.getName()).isEqualTo(doc.get(SolrVorgangMapper.NAME).getValue());
+ assertThat(vorgang.getStatus().name()).isEqualTo(doc.get(SolrVorgangMapper.STATUS).getValue());
+
+ checkEingang(doc);
+ }
+
+ private void checkEingang(SolrInputDocument doc) {
+ assertThat(vorgang.getEingangs().get(0).getZustaendigeStelle().getOrganisationseinheitenId())
+ .isEqualTo(doc.get(SolrVorgangMapper.ORGANISATIONSEINHEITEN_ID).getValue());
+ assertThat(vorgang.getEingangs().get(0).getAntragsteller().getVorname())
+ .isEqualTo(doc.get(SolrVorgangMapper.ANTRAGSTELLER_VORNAME).getValue());
+ assertThat(vorgang.getEingangs().get(0).getAntragsteller().getNachname())
+ .isEqualTo(doc.get(SolrVorgangMapper.ANTRAGSTELLER_NACHNAME).getValue());
+ }
+}
diff --git a/pluto-server/src/test/java/de/itvsh/ozg/pluto/common/solr/VorgangMapperTest.java b/pluto-server/src/test/java/de/itvsh/ozg/pluto/common/solr/VorgangMapperTest.java
deleted file mode 100644
index 3a915f2784f33400d55c1b29076617deb097be24..0000000000000000000000000000000000000000
--- a/pluto-server/src/test/java/de/itvsh/ozg/pluto/common/solr/VorgangMapperTest.java
+++ /dev/null
@@ -1,48 +0,0 @@
-package de.itvsh.ozg.pluto.common.solr;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
-import java.time.ZonedDateTime;
-
-import org.apache.solr.common.SolrInputDocument;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-
-import de.itvsh.ozg.pluto.common.solr.VorgangMapper;
-import de.itvsh.ozg.pluto.vorgang.Antragsteller;
-import de.itvsh.ozg.pluto.vorgang.Eingang;
-import de.itvsh.ozg.pluto.vorgang.Vorgang;
-import de.itvsh.ozg.pluto.vorgang.ZustaendigeStelle;
-
-public class VorgangMapperTest {
- Vorgang vorgang;
- ZonedDateTime dateTime;
-
- @BeforeEach
- void setUp() throws Exception {
- dateTime = ZonedDateTime.now();
- vorgang = Vorgang.builder()
- .aktenzeichen("aktenzeichen")
- .assignedTo("sabine")
- .createdAt(dateTime)
- .eingang(Eingang.builder().antragsteller(Antragsteller.builder().nachname("Mueller").vorname("Max").build())
- .zustaendigeStelle(ZustaendigeStelle.builder().organisationseinheitenId("org_einhait_id").build()).build())
- .name("name")
- .build();
- }
-
- @Test
- void testToSolrInputDocument() {
- SolrInputDocument doc = VorgangMapper.toSolrInputDocument(vorgang);
-
- assertEquals("aktenzeichen", doc.get("aktenzeichen").getValue());
- assertEquals("sabine", doc.get("assignedTo").getValue());
- assertEquals(dateTime, doc.get("createdAt").getValue());
- assertEquals("name", doc.get("name").getValue());
- assertEquals("NEU", doc.get("status").getValue());
- assertEquals("org_einhait_id", doc.get("eingang_zustaendigeStelle_organisationseinheitenId").getValue());
- assertEquals("Max", doc.get("antragsteller_vorname").getValue());
- assertEquals("Mueller", doc.get("antragsteller_nachname").getValue());
- }
-
-}
diff --git a/pluto-server/src/test/resources/application-itcase.yml b/pluto-server/src/test/resources/application-itcase.yml
index 6500e0a581ad96aaf423233fe99809721104eaed..35d5e9eedd0c5418d61b164ca139c735f5c73d5f 100644
--- a/pluto-server/src/test/resources/application-itcase.yml
+++ b/pluto-server/src/test/resources/application-itcase.yml
@@ -21,10 +21,9 @@ kop:
vorgang:
filter:
defaultBehaviour: SHOW_ALL
-
-pluto:
solr:
- hosts: http://localhost:8983/solr
+ hosts:
+ - http://localhost:8983/solr
collection: gettingstarted
mongock:
diff --git a/pluto-server/src/test/resources/application-with_solr.yml b/pluto-server/src/test/resources/application-with_solr.yml
new file mode 100644
index 0000000000000000000000000000000000000000..ba92e8e0f26230b7bafec546153d95cb6cc16bc0
--- /dev/null
+++ b/pluto-server/src/test/resources/application-with_solr.yml
@@ -0,0 +1,5 @@
+kop:
+ solr:
+ hosts:
+ - http://localhost:8983/solr
+ collection: test
\ No newline at end of file