RED-3946 - added alternative quatation marks as separators

redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/redaction/model/SearchableText.java

@@ -177,7 +177,7 @@ public class SearchableText {
 
     private boolean isSeparator(char c) {
 
-        return Character.isWhitespace(c) || Pattern.matches("\\p{Punct}", String.valueOf(c)) || c == '\"' || c == '‘' || c == '’';
+        return Character.isWhitespace(c) || Pattern.matches("\\p{Punct}", String.valueOf(c)) || c == '\"' || c == '‘' || c == '’' || c == '”';
     }
 
 

redaction-service-v1/redaction-service-server-v1/src/main/java/com/iqser/red/service/redaction/v1/server/redaction/service/DictionaryService.java

@@ -125,9 +125,9 @@ public class DictionaryService {
 
                             DictionaryEntries newEntries = getEntries(t.getId(), currentVersion);
 
-                            var newValues = newEntries.getEntries().stream().map(v -> v.getValue()).collect(Collectors.toSet());
+                            var newValues = newEntries.getEntries().stream().map(DictionaryEntry::getValue).collect(Collectors.toSet());
-                            var newFalsePositivesValues = newEntries.getFalsePositives().stream().map(v -> v.getValue()).collect(Collectors.toSet());
+                            var newFalsePositivesValues = newEntries.getFalsePositives().stream().map(DictionaryEntry::getValue).collect(Collectors.toSet());
-                            var newFalseRecommendationsValues = newEntries.getFalseRecommendations().stream().map(v -> v.getValue()).collect(Collectors.toSet());
+                            var newFalseRecommendationsValues = newEntries.getFalseRecommendations().stream().map(DictionaryEntry::getValue).collect(Collectors.toSet());
 
                             // add old entries from existing DictionaryModel
                             oldModel.ifPresent(dictionaryModel -> entries.addAll(dictionaryModel.getEntries().stream().filter(
@@ -200,16 +200,6 @@ public class DictionaryService {
     }
 
 
-    public boolean isCaseInsensitiveDictionary(String type, String dossierTemplateId) {
-
-        DictionaryModel dictionaryModel = dictionariesByDossierTemplate.get(dossierTemplateId).getLocalAccessMap().get(type);
-        if (dictionaryModel != null) {
-            return dictionaryModel.isCaseInsensitive();
-        }
-        return false;
-    }
-
-
     public float[] getColor(String type, String dossierTemplateId) {
 
         DictionaryModel model = dictionariesByDossierTemplate.get(dossierTemplateId).getLocalAccessMap().get(type);
@@ -253,23 +243,12 @@ public class DictionaryService {
     }
 
 
-    public float[] getRequestRemoveColor(String dossierTemplateId) {
-
-        return dictionariesByDossierTemplate.get(dossierTemplateId).getRequestRemoveColor();
-    }
-
-
     public float[] getNotRedactedColor(String dossierTemplateId) {
 
         return dictionariesByDossierTemplate.get(dossierTemplateId).getNotRedactedColor();
     }
 
 
-    public float[] getRequestAddColor(String dossierTemplateId) {
-
-        return dictionariesByDossierTemplate.get(dossierTemplateId).getRequestAddColor();
-    }
-
     private Long getVersion(DictionaryRepresentation dictionaryRepresentation) {
         if (dictionaryRepresentation == null) {
             return null;

redaction-service-v1/redaction-service-server-v1/src/test/java/com/iqser/red/service/redaction/v1/server/DictionaryServiceTest.java

@@ -0,0 +1,115 @@
+package com.iqser.red.service.redaction.v1.server;
+
+import com.iqser.red.service.persistence.service.v1.api.model.dossiertemplate.configuration.Colors;
+import com.iqser.red.service.persistence.service.v1.api.model.dossiertemplate.type.DictionaryEntry;
+import com.iqser.red.service.persistence.service.v1.api.model.dossiertemplate.type.Type;
+import com.iqser.red.service.redaction.v1.server.client.DictionaryClient;
+import com.iqser.red.service.redaction.v1.server.redaction.model.DictionaryVersion;
+import com.iqser.red.service.redaction.v1.server.redaction.service.DictionaryService;
+import com.iqser.red.storage.commons.StorageAutoConfiguration;
+import com.iqser.red.storage.commons.service.StorageService;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.kie.api.runtime.KieContainer;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
+import org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
+import org.springframework.context.annotation.Primary;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.when;
+
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = Application.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+@Import(RedactionIntegrationTest.RedactionIntegrationTestConfiguration.class)
+public class DictionaryServiceTest {
+
+    @MockBean
+    protected KieContainer kieContainer;
+
+    @MockBean
+    protected DictionaryClient dictionaryClient;
+
+    @Autowired
+    protected DictionaryService dictionaryService;
+
+    @Configuration
+    @EnableAutoConfiguration(exclude = {RabbitAutoConfiguration.class, StorageAutoConfiguration.class})
+    public static class RedactionIntegrationTestConfiguration {
+
+        @Bean
+        @Primary
+        public StorageService inmemoryStorage() {
+
+            return new FileSystemBackedStorageService();
+        }
+
+    }
+
+    @Test
+    public void testDictionaryServiceConsistency() {
+
+        when(dictionaryClient.getVersion(anyString())).thenReturn(0L);
+        when(dictionaryClient.getColors(anyString())).thenReturn(new Colors("dossierTemplateId", "#cccccc",
+                "#cccccc", "#cccccc", "#cccccc", "#cccccc", "#cccccc",
+                "#cccccc", "#cccccc", "#cccccc", "#cccccc"));
+
+        var type1 = new Type();
+        type1.setType("type1");
+        type1.setId("type1");
+        type1.setVersion(1L);
+        type1.setHexColor("#cccccc");
+        type1.setHasDictionary(true);
+        type1.setEntries(Stream.of("a", "b", "c").map(t -> new DictionaryEntry(1, t, 1L, false, "type1")).collect(Collectors.toList()));
+
+
+        var type2 = new Type();
+        type2.setType("type2");
+        type2.setId("type2");
+        type2.setVersion(1L);
+        type2.setHexColor("#cccccc");
+        type2.setHasDictionary(true);
+        type2.setEntries(Stream.of("d", "e", "f").map(t -> new DictionaryEntry(1, t, 1L, false, "type2")).collect(Collectors.toList()));
+
+
+        var type1Updated = new Type();
+        type1Updated.setType("type1");
+        type1Updated.setId("type1");
+        type1Updated.setVersion(2L);
+        type1Updated.setHexColor("#cccccc");
+        type1Updated.setHasDictionary(true);
+        type1Updated.setEntries(Stream.of("z", "q", "x").map(t -> new DictionaryEntry(1, t, 2L, false, "type1")).collect(Collectors.toList()));
+
+
+        when(dictionaryClient.getAllTypesForDossierTemplate(anyString(), anyBoolean())).thenReturn(List.of(type1, type2));
+        when(dictionaryClient.getDictionaryForType("type1", null)).thenReturn(type1);
+        when(dictionaryClient.getDictionaryForType("type2", null)).thenReturn(type2);
+        when(dictionaryClient.getDictionaryForType("type1", 0L)).thenReturn(type1);
+        when(dictionaryClient.getDictionaryForType("type2", 0L)).thenReturn(type2);
+
+        dictionaryService.updateDictionary("dossierTemplateId", null);
+        var increments = dictionaryService.getDictionaryIncrements("dossierTemplateId",
+                DictionaryVersion.builder().dossierTemplateVersion(0L).build(), null);
+
+
+        when(dictionaryClient.getVersion(any())).thenReturn(1L);
+        when(dictionaryClient.getAllTypesForDossierTemplate(anyString(), anyBoolean())).thenReturn(List.of(type1Updated));
+        when(dictionaryClient.getDictionaryForType("type1", 1L)).thenReturn(type1Updated);
+
+        dictionaryService.updateDictionary("dossierTemplateId", null);
+        var updatedIncrements = dictionaryService.getDictionaryIncrements("dossierTemplateId",
+                DictionaryVersion.builder().dossierTemplateVersion(0L).build(), null);
+
+    }
+}