Marmelator/redaction-service
1
0
Fork 0
Code Issues Pull Requests 14 Actions Packages Projects Releases 622 Wiki Activity

RED-9472: seperation of system rules

Browse Source 
pmd fix
This commit is contained in:
yhampe 2024-11-13 12:26:32 +01:00
parent 169500183a
commit e47dc30770
1 changed files with 35 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

83
redaction-service-v1/redaction-service-server-v1/src/test/java/com/iqser/red/service/redaction/v1/server/RuleBuilderTest.java
View File

@ -1,10 +1,5 @@
package com.iqser.red.service.redaction.v1.server; package com.iqser.red.service.redaction.v1.server;
import static com.iqser.red.service.redaction.v1.server.AbstractRedactionIntegrationTest.TEST_DOSSIER_TEMPLATE_ID;
import static org.mockito.Mockito.when;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.io.IOException; import java.io.IOException;
import java.net.URL; import java.net.URL;
import java.nio.file.Path; import java.nio.file.Path;
@ -13,8 +8,10 @@ import java.util.ArrayList;
import java.util.Arrays; import java.util.Arrays;
import java.util.List; import java.util.List;
import com.iqser.red.service.persistence.service.v1.api.shared.model.RuleFileType; import org.junit.jupiter.api.Assertions;
import com.iqser.red.service.persistence.service.v1.api.shared.model.common.JSONPrimitive; import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import com.iqser.red.service.redaction.v1.server.model.RuleMergingResult; import com.iqser.red.service.redaction.v1.server.model.RuleMergingResult;
import com.iqser.red.service.redaction.v1.server.model.drools.RuleClass; import com.iqser.red.service.redaction.v1.server.model.drools.RuleClass;
import com.iqser.red.service.redaction.v1.server.model.drools.RuleCompilationResult; import com.iqser.red.service.redaction.v1.server.model.drools.RuleCompilationResult;
@ -27,35 +24,32 @@ import com.iqser.red.service.redaction.v1.server.service.RuleBuilderService;
import com.iqser.red.service.redaction.v1.server.service.drools.RuleCompilationResultParser; import com.iqser.red.service.redaction.v1.server.service.drools.RuleCompilationResultParser;
import com.knecon.fforesight.tenantcommons.TenantContext; import com.knecon.fforesight.tenantcommons.TenantContext;
import org.junit.jupiter.api.Assertions;
import lombok.SneakyThrows; import lombok.SneakyThrows;
class RuleBuilderTest { class RuleBuilderTest {
private RuleBuilderService ruleBuilderService; private RuleBuilderService ruleBuilderService;
private final List<RuleIdentifier> systemRules = new ArrayList<>(Arrays.asList( private final List<RuleIdentifier> systemRules = new ArrayList<>(Arrays.asList(RuleIdentifier.fromName("AI.*.*"),
RuleIdentifier.fromName("AI.*.*"), RuleIdentifier.fromName("MAN.*.*"),
RuleIdentifier.fromName("MAN.*.*"), RuleIdentifier.fromName("X.*.*"),
RuleIdentifier.fromName("X.*.*"), RuleIdentifier.fromName("DICT.*.*"),
RuleIdentifier.fromName("DICT.*.*"), RuleIdentifier.fromName("FA.*.*"),
RuleIdentifier.fromName("FA.*.*"), RuleIdentifier.fromName("LDS.*.*")));
RuleIdentifier.fromName("LDS.*.*")
));
@BeforeEach @BeforeEach
void setUp() { void setUp() {
ruleBuilderService = new RuleBuilderService(); ruleBuilderService = new RuleBuilderService();
TenantContext.setTenantId("redaction"); TenantContext.setTenantId("redaction");
} }
@Test @Test
@SneakyThrows @SneakyThrows
void removeSystemRulesTest() throws IOException { void removeSystemRulesTest() throws IOException {
URL url = getClass().getClassLoader().getResource("drools");
if (url == null) {
throw new RuntimeException("Drools directory not found in resources");
}
URL url = Thread.currentThread().getContextClassLoader().getResource("drools");
Path path = Paths.get(url.toURI()); Path path = Paths.get(url.toURI());
RuleFileIO.streamAllRuleFilesInDirectory(path) RuleFileIO.streamAllRuleFilesInDirectory(path)
.forEach(file -> testThatSystemRulesAreRemoved(file.toPath())); .forEach(file -> testThatSystemRulesAreRemoved(file.toPath()));
@ -64,20 +58,14 @@ class RuleBuilderTest {
.forEach(file -> testRuleFilesRemainSameAfterSeperationAndReaddingSystemrules(file.toPath())); .forEach(file -> testRuleFilesRemainSameAfterSeperationAndReaddingSystemrules(file.toPath()));
} }
private void testThatSystemRulesAreRemoved(Path path) {
String cleanedRulesWithImports = ruleBuilderService.cleanRuleFileOfSystemRules(
RuleFileIO.getRulesString(path.toFile().getAbsolutePath()),
false
);
String cleanedRulesWithoutImports = ruleBuilderService.cleanRuleFileOfSystemRules(
RuleFileIO.getRulesString(path.toFile().getAbsolutePath()),
true
);
RuleCompilationResult ruleCompilationResultWithImports = private void testThatSystemRulesAreRemoved(Path path) {
RuleCompilationResultParser.buildRuleCompilationResultFromRuleString(cleanedRulesWithImports, false);
RuleCompilationResult ruleCompilationResultWithoutImports = String cleanedRulesWithImports = ruleBuilderService.cleanRuleFileOfSystemRules(RuleFileIO.getRulesString(path.toFile().getAbsolutePath()), false);
RuleCompilationResultParser.buildRuleCompilationResultFromRuleString(cleanedRulesWithoutImports, true); String cleanedRulesWithoutImports = ruleBuilderService.cleanRuleFileOfSystemRules(RuleFileIO.getRulesString(path.toFile().getAbsolutePath()), true);
RuleCompilationResult ruleCompilationResultWithImports = RuleCompilationResultParser.buildRuleCompilationResultFromRuleString(cleanedRulesWithImports, false);
RuleCompilationResult ruleCompilationResultWithoutImports = RuleCompilationResultParser.buildRuleCompilationResultFromRuleString(cleanedRulesWithoutImports, true);
Assertions.assertFalse(checkIfImportsDontExist(ruleCompilationResultWithImports)); Assertions.assertFalse(checkIfImportsDontExist(ruleCompilationResultWithImports));
Assertions.assertTrue(checkIfSystemRulesDontExist(ruleCompilationResultWithImports)); Assertions.assertTrue(checkIfSystemRulesDontExist(ruleCompilationResultWithImports));
@ -88,28 +76,22 @@ class RuleBuilderTest {
Assertions.assertTrue(checkIfQueriesDontExist(ruleCompilationResultWithoutImports)); Assertions.assertTrue(checkIfQueriesDontExist(ruleCompilationResultWithoutImports));
} }
private void testRuleFilesRemainSameAfterSeperationAndReaddingSystemrules(Path path) { private void testRuleFilesRemainSameAfterSeperationAndReaddingSystemrules(Path path) {
String cleanedRulesWithImports = ruleBuilderService.cleanRuleFileOfSystemRules(
RuleFileIO.getRulesString(path.toFile().getAbsolutePath()),
false
);
RuleMergingResult cleanedRuleFileMergedWithSystemRules = ruleBuilderService.mergeUserRulesAndSystemRules( String cleanedRulesWithImports = ruleBuilderService.cleanRuleFileOfSystemRules(RuleFileIO.getRulesString(path.toFile().getAbsolutePath()), false);
RuleFileIO.getRulesString(path.toFile().getAbsolutePath()),
cleanedRulesWithImports
);
RuleFileBluePrint ruleFileBluePrint = RuleFileParser.buildBluePrintFromRulesString( RuleMergingResult cleanedRuleFileMergedWithSystemRules = ruleBuilderService.mergeUserRulesAndSystemRules(RuleFileIO.getRulesString(path.toFile().getAbsolutePath()),
cleanedRuleFileMergedWithSystemRules.getMergedRules() cleanedRulesWithImports);
);
Assertions.assertEquals( RuleFileBluePrint ruleFileBluePrint = RuleFileParser.buildBluePrintFromRulesString(cleanedRuleFileMergedWithSystemRules.getMergedRules());
RuleFileFactory.buildRuleString(ruleFileBluePrint, false, false),
cleanedRuleFileMergedWithSystemRules.getMergedRules() Assertions.assertEquals(RuleFileFactory.buildRuleString(ruleFileBluePrint, false, false), cleanedRuleFileMergedWithSystemRules.getMergedRules());
);
} }
private boolean checkIfSystemRulesDontExist(RuleCompilationResult ruleCompilationResult) { private boolean checkIfSystemRulesDontExist(RuleCompilationResult ruleCompilationResult) {
return ruleCompilationResult.getRuleClasses() return ruleCompilationResult.getRuleClasses()
.stream() .stream()
.map(RuleClass::ruleType) .map(RuleClass::ruleType)
@ -118,11 +100,16 @@ class RuleBuilderTest {
.anyMatch(type -> ruleType.name().equals(type.name()))); .anyMatch(type -> ruleType.name().equals(type.name())));
} }
private boolean checkIfImportsDontExist(RuleCompilationResult ruleCompilationResult) { private boolean checkIfImportsDontExist(RuleCompilationResult ruleCompilationResult) {
return ruleCompilationResult.getImports().isEmpty(); return ruleCompilationResult.getImports().isEmpty();
} }
private boolean checkIfQueriesDontExist(RuleCompilationResult ruleCompilationResult) { private boolean checkIfQueriesDontExist(RuleCompilationResult ruleCompilationResult) {
return ruleCompilationResult.getQueries().isEmpty(); return ruleCompilationResult.getQueries().isEmpty();
} }
} }