diff --git a/redaction-service-v1/redaction-service-server-v1/src/test/java/com/iqser/red/service/redaction/v1/server/RuleBuilderTest.java b/redaction-service-v1/redaction-service-server-v1/src/test/java/com/iqser/red/service/redaction/v1/server/RuleBuilderTest.java
index 181e108a..31d61e1e 100644
--- a/redaction-service-v1/redaction-service-server-v1/src/test/java/com/iqser/red/service/redaction/v1/server/RuleBuilderTest.java
+++ b/redaction-service-v1/redaction-service-server-v1/src/test/java/com/iqser/red/service/redaction/v1/server/RuleBuilderTest.java
@@ -1,10 +1,5 @@
 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.net.URL;
 import java.nio.file.Path;
@@ -13,8 +8,10 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
-import com.iqser.red.service.persistence.service.v1.api.shared.model.RuleFileType;
-import com.iqser.red.service.persistence.service.v1.api.shared.model.common.JSONPrimitive;
+import org.junit.jupiter.api.Assertions;
+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.drools.RuleClass;
 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.knecon.fforesight.tenantcommons.TenantContext;
 
-import org.junit.jupiter.api.Assertions;
 import lombok.SneakyThrows;
 
 class RuleBuilderTest {
 
     private RuleBuilderService ruleBuilderService;
-    private final List<RuleIdentifier> systemRules = new ArrayList<>(Arrays.asList(
-            RuleIdentifier.fromName("AI.*.*"),
-            RuleIdentifier.fromName("MAN.*.*"),
-            RuleIdentifier.fromName("X.*.*"),
-            RuleIdentifier.fromName("DICT.*.*"),
-            RuleIdentifier.fromName("FA.*.*"),
-            RuleIdentifier.fromName("LDS.*.*")
-    ));
+    private final List<RuleIdentifier> systemRules = new ArrayList<>(Arrays.asList(RuleIdentifier.fromName("AI.*.*"),
+                                                                                   RuleIdentifier.fromName("MAN.*.*"),
+                                                                                   RuleIdentifier.fromName("X.*.*"),
+                                                                                   RuleIdentifier.fromName("DICT.*.*"),
+                                                                                   RuleIdentifier.fromName("FA.*.*"),
+                                                                                   RuleIdentifier.fromName("LDS.*.*")));
+
 
     @BeforeEach
     void setUp() {
+
         ruleBuilderService = new RuleBuilderService();
         TenantContext.setTenantId("redaction");
     }
 
+
     @Test
     @SneakyThrows
     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());
         RuleFileIO.streamAllRuleFilesInDirectory(path)
                 .forEach(file -> testThatSystemRulesAreRemoved(file.toPath()));
@@ -64,20 +58,14 @@ class RuleBuilderTest {
                 .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 =
-                RuleCompilationResultParser.buildRuleCompilationResultFromRuleString(cleanedRulesWithImports, false);
-        RuleCompilationResult ruleCompilationResultWithoutImports =
-                RuleCompilationResultParser.buildRuleCompilationResultFromRuleString(cleanedRulesWithoutImports, true);
+    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 = RuleCompilationResultParser.buildRuleCompilationResultFromRuleString(cleanedRulesWithImports, false);
+        RuleCompilationResult ruleCompilationResultWithoutImports = RuleCompilationResultParser.buildRuleCompilationResultFromRuleString(cleanedRulesWithoutImports, true);
 
         Assertions.assertFalse(checkIfImportsDontExist(ruleCompilationResultWithImports));
         Assertions.assertTrue(checkIfSystemRulesDontExist(ruleCompilationResultWithImports));
@@ -88,28 +76,22 @@ class RuleBuilderTest {
         Assertions.assertTrue(checkIfQueriesDontExist(ruleCompilationResultWithoutImports));
     }
 
+
     private void testRuleFilesRemainSameAfterSeperationAndReaddingSystemrules(Path path) {
-        String cleanedRulesWithImports = ruleBuilderService.cleanRuleFileOfSystemRules(
-                RuleFileIO.getRulesString(path.toFile().getAbsolutePath()),
-                false
-        );
 
-        RuleMergingResult cleanedRuleFileMergedWithSystemRules = ruleBuilderService.mergeUserRulesAndSystemRules(
-                RuleFileIO.getRulesString(path.toFile().getAbsolutePath()),
-                cleanedRulesWithImports
-        );
+        String cleanedRulesWithImports = ruleBuilderService.cleanRuleFileOfSystemRules(RuleFileIO.getRulesString(path.toFile().getAbsolutePath()), false);
 
-        RuleFileBluePrint ruleFileBluePrint = RuleFileParser.buildBluePrintFromRulesString(
-                cleanedRuleFileMergedWithSystemRules.getMergedRules()
-        );
+        RuleMergingResult cleanedRuleFileMergedWithSystemRules = ruleBuilderService.mergeUserRulesAndSystemRules(RuleFileIO.getRulesString(path.toFile().getAbsolutePath()),
+                                                                                                                 cleanedRulesWithImports);
 
-        Assertions.assertEquals(
-                RuleFileFactory.buildRuleString(ruleFileBluePrint, false, false),
-                cleanedRuleFileMergedWithSystemRules.getMergedRules()
-        );
+        RuleFileBluePrint ruleFileBluePrint = RuleFileParser.buildBluePrintFromRulesString(cleanedRuleFileMergedWithSystemRules.getMergedRules());
+
+        Assertions.assertEquals(RuleFileFactory.buildRuleString(ruleFileBluePrint, false, false), cleanedRuleFileMergedWithSystemRules.getMergedRules());
     }
 
+
     private boolean checkIfSystemRulesDontExist(RuleCompilationResult ruleCompilationResult) {
+
         return ruleCompilationResult.getRuleClasses()
                 .stream()
                 .map(RuleClass::ruleType)
@@ -118,11 +100,16 @@ class RuleBuilderTest {
                         .anyMatch(type -> ruleType.name().equals(type.name())));
     }
 
+
     private boolean checkIfImportsDontExist(RuleCompilationResult ruleCompilationResult) {
+
         return ruleCompilationResult.getImports().isEmpty();
     }
 
+
     private boolean checkIfQueriesDontExist(RuleCompilationResult ruleCompilationResult) {
+
         return ruleCompilationResult.getQueries().isEmpty();
     }
+
 }
\ No newline at end of file