TSK-1633: small refactoring

Co-authored-by: SebastianRoseneck <55637012+SebastianRoseneck@users.noreply.github.com>

history/taskana-loghistory-provider/src/main/java/pro/taskana/loghistory/impl/LogfileHistoryServiceImpl.java

@@ -3,18 +3,10 @@ package pro.taskana.loghistory.impl;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.nio.charset.StandardCharsets;
 import java.util.List;
-import java.util.Properties;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import pro.taskana.TaskanaEngineConfiguration;
 import pro.taskana.common.api.TaskanaEngine;
 import pro.taskana.common.api.exceptions.SystemException;
 import pro.taskana.spi.history.api.TaskanaHistory;
@@ -24,21 +16,23 @@ import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEvent;
 
 public class LogfileHistoryServiceImpl implements TaskanaHistory {
 
+  public static final String TASKANA_HISTORY_LOGGER_NAME = "taskana.historylogger.name";
   private static final Logger LOGGER = LoggerFactory.getLogger(LogfileHistoryServiceImpl.class);
-  private static final String TASKANA_PROPERTIES = "/taskana.properties";
-  private static final String TASKANA_HISTORYLOGGER_NAME = "taskana.historylogger.name";
   private static final String JSON_EXCEPTION =
       "Caught exception while serializing history event to JSON ";
-  private static Logger historyLogger;
-  ObjectMapper objectMapper = new ObjectMapper();
+  private ObjectMapper objectMapper;
+  private Logger historyLogger;
 
   @Override
   public void initialize(TaskanaEngine taskanaEngine) {
 
-    objectMapper.registerModule(new JavaTimeModule());
+    objectMapper = new ObjectMapper().registerModule(new JavaTimeModule());
 
     String historyLoggerName =
-        readPropertiesFromFile(TASKANA_PROPERTIES).getProperty(TASKANA_HISTORYLOGGER_NAME);
+        taskanaEngine
+            .getConfiguration()
+            .readPropertiesFromFile()
+            .getProperty(TASKANA_HISTORY_LOGGER_NAME);
 
     if (historyLoggerName != null) {
       historyLogger = LoggerFactory.getLogger(historyLoggerName);
@@ -92,44 +86,4 @@ public class LogfileHistoryServiceImpl implements TaskanaHistory {
   public void deleteHistoryEventsByTaskIds(List<String> taskIds) {
     throw new UnsupportedOperationException("HistoryLogger is not supposed to delete events");
   }
-
-  private Properties readPropertiesFromFile(String propertiesFile) {
-    Properties props = new Properties();
-    boolean loadFromClasspath = loadFromClasspath(propertiesFile);
-    try {
-      if (loadFromClasspath) {
-        InputStream inputStream =
-            TaskanaEngineConfiguration.class.getResourceAsStream(propertiesFile);
-        if (inputStream == null) {
-          LOGGER.error("taskana properties file {} was not found on classpath.", propertiesFile);
-        } else {
-          props.load(new InputStreamReader(inputStream, StandardCharsets.UTF_8));
-          if (LOGGER.isDebugEnabled()) {
-            LOGGER.debug("properties were loaded from file {} from classpath.", propertiesFile);
-          }
-        }
-      } else {
-        try (FileInputStream stream = new FileInputStream(propertiesFile)) {
-          props.load(stream);
-        }
-        if (LOGGER.isDebugEnabled()) {
-          LOGGER.debug("properties were loaded from file {}.", propertiesFile);
-        }
-      }
-    } catch (IOException e) {
-      LOGGER.error("caught IOException when processing properties file {}.", propertiesFile);
-      throw new SystemException(
-          "internal System error when processing properties file " + propertiesFile, e.getCause());
-    }
-    return props;
-  }
-
-  private boolean loadFromClasspath(String propertiesFile) {
-    boolean loadFromClasspath = true;
-    File f = new File(propertiesFile);
-    if (f.exists() && !f.isDirectory()) {
-      loadFromClasspath = false;
-    }
-    return loadFromClasspath;
-  }
 }

history/taskana-loghistory-provider/src/test/java/pro/taskana/loghistory/impl/LogfileHistoryServiceImplTest.java

@@ -5,13 +5,15 @@ import static org.assertj.core.api.Assertions.assertThat;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
 import java.time.Instant;
+import java.util.Properties;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
-import org.mockito.Mock;
+import org.mockito.Mockito;
 import uk.org.lidalia.slf4jtest.TestLogger;
 import uk.org.lidalia.slf4jtest.TestLoggerFactory;
 
+import pro.taskana.TaskanaEngineConfiguration;
 import pro.taskana.common.api.TaskanaEngine;
 import pro.taskana.spi.history.api.events.classification.ClassificationHistoryEvent;
 import pro.taskana.spi.history.api.events.classification.ClassificationHistoryEventType;
@@ -22,10 +24,11 @@ import pro.taskana.spi.history.api.events.workbasket.WorkbasketHistoryEventType;
 
 class LogfileHistoryServiceImplTest {
 
-  static ObjectMapper objectMapper = new ObjectMapper();
-  LogfileHistoryServiceImpl logfileHistoryServiceImpl = new LogfileHistoryServiceImpl();
-  TestLogger logger = TestLoggerFactory.getTestLogger("AUDIT");
-  @Mock TaskanaEngine taskanaEngine;
+  private final ObjectMapper objectMapper = new ObjectMapper().registerModule(new JavaTimeModule());
+  private final LogfileHistoryServiceImpl logfileHistoryServiceImpl =
+      new LogfileHistoryServiceImpl();
+  private final TestLogger logger = TestLoggerFactory.getTestLogger("AUDIT");
+  static TaskanaEngine taskanaEngineMock;
 
   @AfterEach
   public void clearLoggers() {
@@ -34,13 +37,19 @@ class LogfileHistoryServiceImplTest {
 
   @BeforeAll
   public static void setupObjectMapper() {
-    objectMapper.registerModule(new JavaTimeModule());
+    TaskanaEngineConfiguration taskanaEngineConfiguration =
+        Mockito.mock(TaskanaEngineConfiguration.class);
+    taskanaEngineMock = Mockito.mock(TaskanaEngine.class);
+    Mockito.when(taskanaEngineMock.getConfiguration()).thenReturn(taskanaEngineConfiguration);
+    Properties mockProperties = new Properties();
+    mockProperties.put(LogfileHistoryServiceImpl.TASKANA_HISTORY_LOGGER_NAME, "AUDIT");
+    Mockito.when(taskanaEngineConfiguration.readPropertiesFromFile()).thenReturn(mockProperties);
   }
 
   @Test
   void should_LogTaskEventAsJson_When_CreateIsCalled() throws Exception {
 
-    logfileHistoryServiceImpl.initialize(taskanaEngine);
+    logfileHistoryServiceImpl.initialize(taskanaEngineMock);
     TaskHistoryEvent eventToBeLogged = new TaskHistoryEvent();
     eventToBeLogged.setId("someId");
     eventToBeLogged.setUserId("someUser");
@@ -67,8 +76,7 @@ class LogfileHistoryServiceImplTest {
 
   @Test
   void should_LogWorkbasketEventAsJson_When_CreateIsCalled() throws Exception {
-
-    logfileHistoryServiceImpl.initialize(taskanaEngine);
+    logfileHistoryServiceImpl.initialize(taskanaEngineMock);
     WorkbasketHistoryEvent eventToBeLogged = new WorkbasketHistoryEvent();
     eventToBeLogged.setId("someId");
     eventToBeLogged.setUserId("someUser");
@@ -91,7 +99,7 @@ class LogfileHistoryServiceImplTest {
   @Test
   void should_LogClassificationEventAsJson_When_CreateIsCalled() throws Exception {
 
-    logfileHistoryServiceImpl.initialize(taskanaEngine);
+    logfileHistoryServiceImpl.initialize(taskanaEngineMock);
     ClassificationHistoryEvent eventToBeLogged = new ClassificationHistoryEvent();
     eventToBeLogged.setId("someId");
     eventToBeLogged.setUserId("someUser");

history/taskana-loghistory-provider/src/test/resources/taskana.properties

@@ -1,25 +0,0 @@
-taskana.roles.user=cn=ksc-users,cn=groups,OU=Test,O=TASKANA | teamlead-1 | teamlead-2 | user-1-1 | user-1-2 | user-2-1 | user-2-2 | user-b-1 | user-b-2
-taskana.roles.admin=admin | uid=admin,cn=users,OU=Test,O=TASKANA
-taskana.roles.businessadmin=businessadmin | cn=business-admins,cn=groups,OU=Test,O=TASKANA
-taskana.roles.monitor=monitor | cn=monitor-users,cn=groups,OU=Test,O=TASKANA
-taskana.roles.taskadmin=taskadmin
-
-taskana.domains=DOMAIN_A,DOMAIN_B,DOMAIN_C
-taskana.classification.types=TASK,DOCUMENT
-taskana.classification.categories.task= EXTERNAL, manual, autoMAtic, Process
-taskana.classification.categories.document= EXTERNAL
-
-taskana.jobs.maxRetries=3
-taskana.jobs.batchSize=50
-taskana.jobs.cleanup.runEvery=P1D
-taskana.jobs.cleanup.firstRunAt=2018-07-25T08:00:00Z
-taskana.jobs.cleanup.minimumAge=P14D
-taskana.jobs.history.batchSize=50
-taskana.jobs.history.cleanup.firstRunAt=2018-07-25T08:00:00Z
-taskana.jobs.history.cleanup.minimumAge=P14D
-taskana.jobs.history.cleanup.runEvery=P1D
-taskana.german.holidays.enabled=true
-taskana.german.holidays.corpus-christi.enabled=true
-
-taskana.historylogger.name=AUDIT
-

lib/taskana-core/src/test/java/acceptance/priorityservice/TestPriorityServiceProvider.java

@@ -1,9 +1,8 @@
 package acceptance.priorityservice;
 
-import java.sql.Date;
+import java.time.Duration;
 import java.time.Instant;
 import java.util.Optional;
-import java.util.concurrent.TimeUnit;
 
 import pro.taskana.spi.priority.api.PriorityServiceProvider;
 import pro.taskana.task.api.TaskCustomField;
@@ -14,14 +13,12 @@ public class TestPriorityServiceProvider implements PriorityServiceProvider {
 
   @Override
   public Optional<Integer> calculatePriority(TaskSummary taskSummary) {
-    long diffInMillies =
-        Date.from(Instant.now()).getTime() - Date.from(taskSummary.getCreated()).getTime();
-    long diffInDays = TimeUnit.DAYS.convert(diffInMillies, TimeUnit.MILLISECONDS);
+    long diffInDays = Duration.between(taskSummary.getCreated(), Instant.now()).toDays();
     int priority = diffInDays >= 1 ? Math.toIntExact(diffInDays) : 1;
 
-    if (taskSummary.getCustomAttribute(TaskCustomField.CUSTOM_6) == "true") {
+    if ("true".equals(taskSummary.getCustomAttribute(TaskCustomField.CUSTOM_6))) {
       priority *= MULTIPLIER;
     }
-    return Optional.of(Integer.valueOf(priority));
+    return Optional.of(priority);
   }
 }