From 109df2fe0fdd5ea594f8dc42fff18b8ab78c707d Mon Sep 17 00:00:00 2001 From: Julien Lancelot Date: Wed, 24 Feb 2016 20:28:45 +0100 Subject: [PATCH] SONAR-7330 RuleActivator is now using ActiveRuleIndexer --- .../server/qualityprofile/RuleActivator.java | 35 +- .../RuleActivatorMediumTest.java | 584 ++++++++++-------- 2 files changed, 335 insertions(+), 284 deletions(-) diff --git a/server/sonar-server/src/main/java/org/sonar/server/qualityprofile/RuleActivator.java b/server/sonar-server/src/main/java/org/sonar/server/qualityprofile/RuleActivator.java index 8a0841b4c49..f73164f415e 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/qualityprofile/RuleActivator.java +++ b/server/sonar-server/src/main/java/org/sonar/server/qualityprofile/RuleActivator.java @@ -21,6 +21,8 @@ package org.sonar.server.qualityprofile; import com.google.common.base.Splitter; import com.google.common.collect.Lists; +import java.util.ArrayList; +import java.util.Collections; import java.util.Iterator; import java.util.List; import java.util.Map; @@ -41,6 +43,7 @@ import org.sonar.db.rule.RuleDto; import org.sonar.db.rule.RuleParamDto; import org.sonar.server.activity.ActivityService; import org.sonar.server.exceptions.BadRequestException; +import org.sonar.server.qualityprofile.index.ActiveRuleIndexer; import org.sonar.server.rule.index.RuleIndex2; import org.sonar.server.rule.index.RuleQuery; import org.sonar.server.util.TypeValidations; @@ -58,16 +61,18 @@ public class RuleActivator { private final TypeValidations typeValidations; private final RuleActivatorContextFactory contextFactory; private final RuleIndex2 ruleIndex; + private final ActiveRuleIndexer activeRuleIndexer; private final ActivityService activityService; public RuleActivator(System2 system2, DbClient db, RuleIndex2 ruleIndex, RuleActivatorContextFactory contextFactory, TypeValidations typeValidations, - ActivityService activityService) { + ActiveRuleIndexer activeRuleIndexer, ActivityService activityService) { this.system2 = system2; this.db = db; this.ruleIndex = ruleIndex; this.contextFactory = contextFactory; this.typeValidations = typeValidations; + this.activeRuleIndexer = activeRuleIndexer; this.activityService = activityService; } @@ -311,6 +316,7 @@ public class RuleActivator { try { List changes = deactivate(dbSession, key); dbSession.commit(); + activeRuleIndexer.index(changes); return changes; } finally { dbSession.close(); @@ -388,8 +394,8 @@ public class RuleActivator { } BulkChangeResult bulkActivate(RuleQuery ruleQuery, String profileKey, @Nullable String severity) { - BulkChangeResult result = new BulkChangeResult(); DbSession dbSession = db.openSession(false); + BulkChangeResult result = new BulkChangeResult(); try { Iterator rules = ruleIndex.searchAll(ruleQuery); while (rules.hasNext()) { @@ -410,6 +416,7 @@ public class RuleActivator { } } dbSession.commit(); + activeRuleIndexer.index(result.getChanges()); } finally { dbSession.close(); } @@ -418,8 +425,8 @@ public class RuleActivator { BulkChangeResult bulkDeactivate(RuleQuery ruleQuery, String profile) { DbSession dbSession = db.openSession(false); + BulkChangeResult result = new BulkChangeResult(); try { - BulkChangeResult result = new BulkChangeResult(); Iterator rules = ruleIndex.searchAll(ruleQuery); while (rules.hasNext()) { try { @@ -437,6 +444,7 @@ public class RuleActivator { } } dbSession.commit(); + activeRuleIndexer.index(result.getChanges()); return result; } finally { dbSession.close(); @@ -446,26 +454,28 @@ public class RuleActivator { public void setParent(String key, @Nullable String parentKey) { DbSession dbSession = db.openSession(false); try { - setParent(dbSession, key, parentKey); + List changes = setParent(dbSession, key, parentKey); dbSession.commit(); + activeRuleIndexer.index(changes); } finally { dbSession.close(); } } - void setParent(DbSession dbSession, String profileKey, @Nullable String parentKey) { + List setParent(DbSession dbSession, String profileKey, @Nullable String parentKey) { QualityProfileDto profile = db.qualityProfileDao().selectOrFailByKey(dbSession, profileKey); + List changes = new ArrayList<>(); if (parentKey == null) { // unset if parent is defined, else nothing to do - removeParent(dbSession, profile); + changes.addAll(removeParent(dbSession, profile)); } else if (profile.getParentKee() == null || !parentKey.equals(profile.getParentKee())) { QualityProfileDto parentProfile = db.qualityProfileDao().selectOrFailByKey(dbSession, parentKey); if (isDescendant(dbSession, profile, parentProfile)) { throw new BadRequestException(String.format("Descendant profile '%s' can not be selected as parent of '%s'", parentKey, profileKey)); } - removeParent(dbSession, profile); + changes.addAll(removeParent(dbSession, profile)); // set new parent profile.setParentKee(parentKey); @@ -473,32 +483,37 @@ public class RuleActivator { for (ActiveRuleDto parentActiveRule : db.activeRuleDao().selectByProfileKey(dbSession, parentKey)) { try { RuleActivation activation = new RuleActivation(parentActiveRule.getKey().ruleKey()); - activate(dbSession, activation, profileKey); + changes.addAll(activate(dbSession, activation, profileKey)); } catch (BadRequestException e) { // for example because rule status is REMOVED // TODO return errors } } } + return changes; } /** * Does not commit */ - private void removeParent(DbSession dbSession, QualityProfileDto profileDto) { + private List removeParent(DbSession dbSession, QualityProfileDto profileDto) { if (profileDto.getParentKee() != null) { + List changes = new ArrayList<>(); profileDto.setParentKee(null); db.qualityProfileDao().update(dbSession, profileDto); for (ActiveRuleDto activeRule : db.activeRuleDao().selectByProfileKey(dbSession, profileDto.getKey())) { if (ActiveRuleDto.INHERITED.equals(activeRule.getInheritance())) { - deactivate(dbSession, activeRule.getKey(), true); + changes.addAll(deactivate(dbSession, activeRule.getKey(), true)); } else if (ActiveRuleDto.OVERRIDES.equals(activeRule.getInheritance())) { activeRule.setInheritance(null); activeRule.setUpdatedAtInMs(system2.now()); db.activeRuleDao().update(dbSession, activeRule); + changes.add(ActiveRuleChange.createFor(ActiveRuleChange.Type.UPDATED, activeRule.getKey()).setInheritance(null)); } } + return changes; } + return Collections.emptyList(); } boolean isDescendant(DbSession dbSession, QualityProfileDto childProfile, @Nullable QualityProfileDto parentProfile) { diff --git a/server/sonar-server/src/test/java/org/sonar/server/qualityprofile/RuleActivatorMediumTest.java b/server/sonar-server/src/test/java/org/sonar/server/qualityprofile/RuleActivatorMediumTest.java index 8bda831464f..28724162f81 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/qualityprofile/RuleActivatorMediumTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/qualityprofile/RuleActivatorMediumTest.java @@ -33,8 +33,8 @@ import org.junit.Rule; import org.junit.Test; import org.sonar.api.rule.RuleKey; import org.sonar.api.rule.RuleStatus; -import org.sonar.api.rule.Severity; import org.sonar.api.server.rule.RuleParamType; +import org.sonar.db.DbClient; import org.sonar.db.DbSession; import org.sonar.db.qualityprofile.ActiveRuleDto; import org.sonar.db.qualityprofile.ActiveRuleKey; @@ -42,12 +42,14 @@ import org.sonar.db.qualityprofile.ActiveRuleParamDto; import org.sonar.db.qualityprofile.QualityProfileDto; import org.sonar.db.rule.RuleDto; import org.sonar.db.rule.RuleParamDto; -import org.sonar.db.rule.RuleTesting; -import org.sonar.server.db.DbClient; +import org.sonar.server.es.SearchOptions; import org.sonar.server.exceptions.BadRequestException; import org.sonar.server.exceptions.Message; -import org.sonar.server.qualityprofile.index.ActiveRuleIndex; -import org.sonar.server.rule.index.RuleIndex; +import org.sonar.server.qualityprofile.index.ActiveRuleDoc; +import org.sonar.server.qualityprofile.index.ActiveRuleIndex2; +import org.sonar.server.qualityprofile.index.ActiveRuleIndexer; +import org.sonar.server.rule.index.RuleIndex2; +import org.sonar.server.rule.index.RuleIndexer; import org.sonar.server.rule.index.RuleQuery; import org.sonar.server.search.QueryContext; import org.sonar.server.tester.ServerTester; @@ -55,10 +57,25 @@ import org.sonar.server.tester.UserSessionRule; import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.fail; +import static org.sonar.api.rule.Severity.BLOCKER; +import static org.sonar.api.rule.Severity.CRITICAL; +import static org.sonar.api.rule.Severity.INFO; +import static org.sonar.api.rule.Severity.MAJOR; +import static org.sonar.api.rule.Severity.MINOR; +import static org.sonar.db.qualityprofile.ActiveRuleDto.INHERITED; +import static org.sonar.db.qualityprofile.ActiveRuleDto.OVERRIDES; +import static org.sonar.db.rule.RuleTesting.XOO_X1; +import static org.sonar.db.rule.RuleTesting.XOO_X2; +import static org.sonar.db.rule.RuleTesting.newCustomRule; +import static org.sonar.db.rule.RuleTesting.newDto; +import static org.sonar.db.rule.RuleTesting.newTemplateRule; +import static org.sonar.db.rule.RuleTesting.newXooX1; +import static org.sonar.db.rule.RuleTesting.newXooX2; import static org.sonar.server.qualityprofile.QProfileTesting.XOO_P1_KEY; import static org.sonar.server.qualityprofile.QProfileTesting.XOO_P2_KEY; import static org.sonar.server.qualityprofile.QProfileTesting.XOO_P3_KEY; +// TODO Replace ServerTester by EsTester and DbTester public class RuleActivatorMediumTest { static final RuleKey MANUAL_RULE_KEY = RuleKey.of(RuleKey.MANUAL_REPOSITORY_KEY, "m1"); @@ -66,14 +83,20 @@ public class RuleActivatorMediumTest { static final RuleKey CUSTOM_RULE_KEY = RuleKey.of("xoo", "custom1"); @ClassRule - public static ServerTester tester = new ServerTester(); + public static ServerTester tester = new ServerTester().withEsIndexes(); + @Rule public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester); DbClient db; DbSession dbSession; + RuleActivator ruleActivator; - ActiveRuleIndex index; + + RuleIndexer ruleIndexer; + + ActiveRuleIndex2 activeRuleIndex; + ActiveRuleIndexer activeRuleIndexer; QualityProfileDto profileDto; @@ -83,28 +106,36 @@ public class RuleActivatorMediumTest { db = tester.get(DbClient.class); dbSession = db.openSession(false); ruleActivator = tester.get(RuleActivator.class); - index = tester.get(ActiveRuleIndex.class); + activeRuleIndex = tester.get(ActiveRuleIndex2.class); + activeRuleIndexer = tester.get(ActiveRuleIndexer.class); + activeRuleIndexer.setEnabled(true); + ruleIndexer = tester.get(RuleIndexer.class); + ruleIndexer.setEnabled(true); // create pre-defined rules - RuleDto javaRule = RuleTesting.newDto(RuleKey.of("squid", "j1")) + RuleDto javaRule = newDto(RuleKey.of("squid", "j1")) .setSeverity("MAJOR").setLanguage("java"); - RuleDto xooRule1 = RuleTesting.newXooX1().setSeverity("MINOR"); - RuleDto xooRule2 = RuleTesting.newXooX2().setSeverity("INFO"); - RuleDto xooTemplateRule1 = RuleTesting.newTemplateRule(TEMPLATE_RULE_KEY) + RuleDto xooRule1 = newXooX1().setSeverity("MINOR"); + RuleDto xooRule2 = newXooX2().setSeverity("INFO"); + RuleDto xooTemplateRule1 = newTemplateRule(TEMPLATE_RULE_KEY) .setSeverity("MINOR").setLanguage("xoo"); - RuleDto manualRule = RuleTesting.newDto(MANUAL_RULE_KEY); - db.deprecatedRuleDao().insert(dbSession, javaRule, xooRule1, xooRule2, xooTemplateRule1, manualRule); - db.deprecatedRuleDao().insertRuleParam(dbSession, xooRule1, RuleParamDto.createFor(xooRule1) + RuleDto manualRule = newDto(MANUAL_RULE_KEY); + db.ruleDao().insert(dbSession, javaRule); + db.ruleDao().insert(dbSession, xooRule1); + db.ruleDao().insert(dbSession, xooRule2); + db.ruleDao().insert(dbSession, xooTemplateRule1); + db.ruleDao().insert(dbSession, manualRule); + db.ruleDao().insertRuleParam(dbSession, xooRule1, RuleParamDto.createFor(xooRule1) .setName("max").setDefaultValue("10").setType(RuleParamType.INTEGER.type())); - db.deprecatedRuleDao().insertRuleParam(dbSession, xooRule1, RuleParamDto.createFor(xooRule1) + db.ruleDao().insertRuleParam(dbSession, xooRule1, RuleParamDto.createFor(xooRule1) .setName("min").setType(RuleParamType.INTEGER.type())); - db.deprecatedRuleDao().insertRuleParam(dbSession, xooTemplateRule1, RuleParamDto.createFor(xooTemplateRule1) + db.ruleDao().insertRuleParam(dbSession, xooTemplateRule1, RuleParamDto.createFor(xooTemplateRule1) .setName("format").setType(RuleParamType.STRING.type())); - RuleDto xooCustomRule1 = RuleTesting.newCustomRule(xooTemplateRule1).setRuleKey(CUSTOM_RULE_KEY.rule()) + RuleDto xooCustomRule1 = newCustomRule(xooTemplateRule1).setRuleKey(CUSTOM_RULE_KEY.rule()) .setSeverity("MINOR").setLanguage("xoo"); - db.deprecatedRuleDao().insert(dbSession, xooCustomRule1); - db.deprecatedRuleDao().insertRuleParam(dbSession, xooCustomRule1, RuleParamDto.createFor(xooTemplateRule1) + db.ruleDao().insert(dbSession, xooCustomRule1); + db.ruleDao().insertRuleParam(dbSession, xooCustomRule1, RuleParamDto.createFor(xooTemplateRule1) .setName("format").setDefaultValue("txt").setType(RuleParamType.STRING.type())); // create pre-defined profile P1 @@ -112,6 +143,7 @@ public class RuleActivatorMediumTest { db.qualityProfileDao().insert(dbSession, profileDto); dbSession.commit(); dbSession.clearCache(); + ruleIndexer.index(); } @After @@ -121,8 +153,8 @@ public class RuleActivatorMediumTest { @Test public void activate() { - RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1); - activation.setSeverity(Severity.BLOCKER); + RuleActivation activation = new RuleActivation(XOO_X1); + activation.setSeverity(BLOCKER); activation.setParameter("max", "7"); activation.setParameter("min", "3"); List changes = ruleActivator.activate(dbSession, activation, XOO_P1_KEY); @@ -130,7 +162,7 @@ public class RuleActivatorMediumTest { dbSession.clearCache(); assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(1); - verifyHasActiveRule(ActiveRuleKey.of(XOO_P1_KEY, RuleTesting.XOO_X1), Severity.BLOCKER, null, + verifyHasActiveRuleInDb(ActiveRuleKey.of(XOO_P1_KEY, XOO_X1), BLOCKER, null, ImmutableMap.of("max", "7", "min", "3")); assertThat(changes).hasSize(1); assertThat(changes.get(0).getType()).isEqualTo(ActiveRuleChange.Type.ACTIVATED); @@ -138,8 +170,8 @@ public class RuleActivatorMediumTest { @Test public void activate_with_profile_dto() { - RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1); - activation.setSeverity(Severity.BLOCKER); + RuleActivation activation = new RuleActivation(XOO_X1); + activation.setSeverity(BLOCKER); activation.setParameter("max", "7"); activation.setParameter("min", "3"); List changes = ruleActivator.activate(dbSession, activation, profileDto); @@ -147,7 +179,7 @@ public class RuleActivatorMediumTest { dbSession.clearCache(); assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(1); - verifyHasActiveRule(ActiveRuleKey.of(XOO_P1_KEY, RuleTesting.XOO_X1), Severity.BLOCKER, null, + verifyHasActiveRuleInDb(ActiveRuleKey.of(XOO_P1_KEY, XOO_X1), BLOCKER, null, ImmutableMap.of("max", "7", "min", "3")); assertThat(changes).hasSize(1); assertThat(changes.get(0).getType()).isEqualTo(ActiveRuleChange.Type.ACTIVATED); @@ -155,10 +187,10 @@ public class RuleActivatorMediumTest { @Test public void activate_with_default_severity_and_parameter() { - activate(new RuleActivation(RuleTesting.XOO_X1), XOO_P1_KEY); + activate(new RuleActivation(XOO_X1), XOO_P1_KEY); assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(1); - verifyHasActiveRule(ActiveRuleKey.of(XOO_P1_KEY, RuleTesting.XOO_X1), Severity.MINOR, null, + verifyHasActiveRuleInDb(ActiveRuleKey.of(XOO_P1_KEY, XOO_X1), MINOR, null, ImmutableMap.of("max", "10")); } @@ -167,12 +199,12 @@ public class RuleActivatorMediumTest { */ @Test public void activate_with_empty_parameter_having_no_default_value() { - activate(new RuleActivation(RuleTesting.XOO_X1) + activate(new RuleActivation(XOO_X1) .setParameter("min", ""), XOO_P1_KEY); assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(1); - verifyHasActiveRule(ActiveRuleKey.of(XOO_P1_KEY, RuleTesting.XOO_X1), Severity.MINOR, null, + verifyHasActiveRuleInDb(ActiveRuleKey.of(XOO_P1_KEY, XOO_X1), MINOR, null, // Max should be set to default value, min has not value it should be ignored ImmutableMap.of("max", "10")); } @@ -182,13 +214,13 @@ public class RuleActivatorMediumTest { */ @Test public void activate_with_empty_parameters() { - activate(new RuleActivation(RuleTesting.XOO_X1) + activate(new RuleActivation(XOO_X1) .setParameters(ImmutableMap.of("max", "", "min", "")), XOO_P1_KEY); assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(1); // Max should be set to default value, min has not value it should be ignored - verifyHasActiveRule(ActiveRuleKey.of(XOO_P1_KEY, RuleTesting.XOO_X1), Severity.MINOR, null, + verifyHasActiveRuleInDb(ActiveRuleKey.of(XOO_P1_KEY, XOO_X1), MINOR, null, ImmutableMap.of("max", "10")); } @@ -197,41 +229,41 @@ public class RuleActivatorMediumTest { */ @Test public void activate_rule_with_negative_integer_value_on_parameter_having_no_default_value() { - activate(new RuleActivation(RuleTesting.XOO_X1) + activate(new RuleActivation(XOO_X1) .setParameter("min", "-10"), XOO_P1_KEY); assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(1); // Max should be set to default value, min should be set to -10 - verifyHasActiveRule(ActiveRuleKey.of(XOO_P1_KEY, RuleTesting.XOO_X1), Severity.MINOR, null, + verifyHasActiveRuleInDb(ActiveRuleKey.of(XOO_P1_KEY, XOO_X1), MINOR, null, ImmutableMap.of("max", "10", "min", "-10")); } @Test public void activation_ignores_unsupported_parameters() { - RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1); + RuleActivation activation = new RuleActivation(XOO_X1); activation.setParameter("xxx", "yyy"); activate(activation, XOO_P1_KEY); assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(1); - verifyHasActiveRule(ActiveRuleKey.of(XOO_P1_KEY, RuleTesting.XOO_X1), Severity.MINOR, null, ImmutableMap.of("max", "10")); + verifyHasActiveRuleInDb(ActiveRuleKey.of(XOO_P1_KEY, XOO_X1), MINOR, null, ImmutableMap.of("max", "10")); } @Test public void update_activation_severity_and_parameters() { // initial activation - RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1); - activation.setSeverity(Severity.BLOCKER); + RuleActivation activation = new RuleActivation(XOO_X1); + activation.setSeverity(BLOCKER); activate(activation, XOO_P1_KEY); // update - RuleActivation update = new RuleActivation(RuleTesting.XOO_X1); - update.setSeverity(Severity.CRITICAL); + RuleActivation update = new RuleActivation(XOO_X1); + update.setSeverity(CRITICAL); update.setParameter("max", "42"); List changes = activate(update, XOO_P1_KEY); assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(1); - verifyHasActiveRule(ActiveRuleKey.of(XOO_P1_KEY, RuleTesting.XOO_X1), Severity.CRITICAL, null, ImmutableMap.of("max", "42")); + verifyHasActiveRuleInDb(ActiveRuleKey.of(XOO_P1_KEY, XOO_X1), CRITICAL, null, ImmutableMap.of("max", "42")); assertThat(changes).hasSize(1); assertThat(changes.get(0).getType()).isEqualTo(ActiveRuleChange.Type.UPDATED); } @@ -239,18 +271,18 @@ public class RuleActivatorMediumTest { @Test public void update_activation_with_parameter_without_default_value() { // initial activation -> param "max" has a default value - RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1); - activation.setSeverity(Severity.BLOCKER); + RuleActivation activation = new RuleActivation(XOO_X1); + activation.setSeverity(BLOCKER); activate(activation, XOO_P1_KEY); - verifyHasActiveRule(ActiveRuleKey.of(XOO_P1_KEY, RuleTesting.XOO_X1), Severity.BLOCKER, null, + verifyHasActiveRuleInDb(ActiveRuleKey.of(XOO_P1_KEY, XOO_X1), BLOCKER, null, ImmutableMap.of("max", "10")); // update param "min", which has no default value - RuleActivation update = new RuleActivation(RuleTesting.XOO_X1); + RuleActivation update = new RuleActivation(XOO_X1); update.setParameter("min", "3"); List changes = activate(update, XOO_P1_KEY); assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(1); - verifyHasActiveRule(ActiveRuleKey.of(XOO_P1_KEY, RuleTesting.XOO_X1), Severity.BLOCKER, null, + verifyHasActiveRuleInDb(ActiveRuleKey.of(XOO_P1_KEY, XOO_X1), BLOCKER, null, ImmutableMap.of("min", "3", "max", "10")); assertThat(changes).hasSize(1); assertThat(changes.get(0).getType()).isEqualTo(ActiveRuleChange.Type.UPDATED); @@ -259,38 +291,38 @@ public class RuleActivatorMediumTest { @Test public void update_activation_but_new_parameter() { // initial activation - ActiveRuleKey activeRuleKey = ActiveRuleKey.of(XOO_P1_KEY, RuleTesting.XOO_X1); - RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1); - activation.setSeverity(Severity.BLOCKER); + ActiveRuleKey activeRuleKey = ActiveRuleKey.of(XOO_P1_KEY, XOO_X1); + RuleActivation activation = new RuleActivation(XOO_X1); + activation.setSeverity(BLOCKER); activate(activation, XOO_P1_KEY); - assertThat(db.deprecatedActiveRuleDao().selectParamByKeyAndName(activeRuleKey, "max", dbSession)).isNotNull(); - db.deprecatedActiveRuleDao().deleteParamByKeyAndName(dbSession, activeRuleKey, "max"); + assertThat(db.activeRuleDao().selectParamByKeyAndName(activeRuleKey, "max", dbSession)).isNotNull(); + db.activeRuleDao().deleteParamByKeyAndName(dbSession, activeRuleKey, "max"); dbSession.commit(); - assertThat(db.deprecatedActiveRuleDao().selectParamByKeyAndName(activeRuleKey, "max", dbSession)).isNull(); + assertThat(db.activeRuleDao().selectParamByKeyAndName(activeRuleKey, "max", dbSession)).isNull(); dbSession.clearCache(); // update - RuleActivation update = new RuleActivation(RuleTesting.XOO_X1); - update.setSeverity(Severity.CRITICAL); + RuleActivation update = new RuleActivation(XOO_X1); + update.setSeverity(CRITICAL); update.setParameter("max", "42"); // contrary to activerule, the param 'max' is supposed to be inserted but not updated activate(update, XOO_P1_KEY); assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(1); - verifyHasActiveRule(activeRuleKey, Severity.CRITICAL, null, ImmutableMap.of("max", "42")); + verifyHasActiveRuleInDb(activeRuleKey, CRITICAL, null, ImmutableMap.of("max", "42")); } @Test public void ignore_activation_without_changes() { // initial activation - RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1); - activation.setSeverity(Severity.BLOCKER); + RuleActivation activation = new RuleActivation(XOO_X1); + activation.setSeverity(BLOCKER); activate(activation, XOO_P1_KEY); // update with exactly the same severity and params - RuleActivation update = new RuleActivation(RuleTesting.XOO_X1); - update.setSeverity(Severity.BLOCKER); + RuleActivation update = new RuleActivation(XOO_X1); + update.setSeverity(BLOCKER); List changes = activate(update, XOO_P1_KEY); assertThat(changes).isEmpty(); } @@ -298,35 +330,35 @@ public class RuleActivatorMediumTest { @Test public void do_not_change_severity_and_params_if_unset_and_already_activated() { // initial activation - ActiveRuleKey activeRuleKey = ActiveRuleKey.of(XOO_P1_KEY, RuleTesting.XOO_X1); - RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1); - activation.setSeverity(Severity.BLOCKER); + ActiveRuleKey activeRuleKey = ActiveRuleKey.of(XOO_P1_KEY, XOO_X1); + RuleActivation activation = new RuleActivation(XOO_X1); + activation.setSeverity(BLOCKER); activation.setParameter("max", "7"); activate(activation, XOO_P1_KEY); // update without any severity or params => keep - RuleActivation update = new RuleActivation(RuleTesting.XOO_X1); + RuleActivation update = new RuleActivation(XOO_X1); activate(update, XOO_P1_KEY); assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(1); - verifyHasActiveRule(activeRuleKey, Severity.BLOCKER, null, ImmutableMap.of("max", "7")); + verifyHasActiveRuleInDb(activeRuleKey, BLOCKER, null, ImmutableMap.of("max", "7")); } @Test public void revert_activation_to_default_severity_and_parameters() { // initial activation - ActiveRuleKey activeRuleKey = ActiveRuleKey.of(XOO_P1_KEY, RuleTesting.XOO_X1); - RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1); - activation.setSeverity(Severity.BLOCKER); + ActiveRuleKey activeRuleKey = ActiveRuleKey.of(XOO_P1_KEY, XOO_X1); + RuleActivation activation = new RuleActivation(XOO_X1); + activation.setSeverity(BLOCKER); activation.setParameter("max", "7"); activation.setParameter("min", "3"); activate(activation, XOO_P1_KEY); // update without any severity or params = reset - RuleActivation update = new RuleActivation(RuleTesting.XOO_X1).setReset(true); + RuleActivation update = new RuleActivation(XOO_X1).setReset(true); activate(update, XOO_P1_KEY); assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(1); - verifyHasActiveRule(activeRuleKey, Severity.MINOR, null, + verifyHasActiveRuleInDb(activeRuleKey, MINOR, null, // only default values ImmutableMap.of("max", "10")); } @@ -344,7 +376,7 @@ public class RuleActivatorMediumTest { activate(update, XOO_P1_KEY); assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(1); - verifyHasActiveRule(activeRuleKey, Severity.MINOR, null, ImmutableMap.of("format", "txt")); + verifyHasActiveRuleInDb(activeRuleKey, MINOR, null, ImmutableMap.of("format", "txt")); } @Test @@ -390,13 +422,13 @@ public class RuleActivatorMediumTest { @Test public void fail_to_activate_if_rule_with_removed_status() { - RuleDto ruleDto = db.deprecatedRuleDao().getByKey(dbSession, RuleTesting.XOO_X1); + RuleDto ruleDto = db.ruleDao().selectOrFailByKey(dbSession, XOO_X1); ruleDto.setStatus(RuleStatus.REMOVED); - db.deprecatedRuleDao().update(dbSession, ruleDto); + db.ruleDao().update(dbSession, ruleDto); dbSession.commit(); dbSession.clearCache(); - RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1); + RuleActivation activation = new RuleActivation(XOO_X1); try { activate(activation, XOO_P1_KEY); @@ -423,7 +455,7 @@ public class RuleActivatorMediumTest { @Test public void fail_to_activate_if_unknown_profile() { try { - activate(new RuleActivation(RuleTesting.XOO_X1), "unknown"); + activate(new RuleActivation(XOO_X1), "unknown"); fail(); } catch (BadRequestException e) { assertThat(e).hasMessage("Quality profile not found: unknown"); @@ -432,7 +464,7 @@ public class RuleActivatorMediumTest { @Test public void fail_to_activate_if_invalid_parameter() { - RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1); + RuleActivation activation = new RuleActivation(XOO_X1); activation.setParameter("max", "foo"); try { @@ -448,13 +480,13 @@ public class RuleActivatorMediumTest { @Test public void deactivate() { // activation - RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1); - activation.setSeverity(Severity.BLOCKER); + RuleActivation activation = new RuleActivation(XOO_X1); + activation.setSeverity(BLOCKER); activation.setParameter("max", "7"); activate(activation, XOO_P1_KEY); // deactivation - ruleActivator.deactivate(ActiveRuleKey.of(XOO_P1_KEY, RuleTesting.XOO_X1)); + ruleActivator.deactivate(ActiveRuleKey.of(XOO_P1_KEY, XOO_X1)); verifyZeroActiveRules(XOO_P1_KEY); } @@ -462,7 +494,7 @@ public class RuleActivatorMediumTest { @Test public void ignore_deactivation_if_rule_not_activated() { // deactivation - ActiveRuleKey key = ActiveRuleKey.of(XOO_P1_KEY, RuleTesting.XOO_X1); + ActiveRuleKey key = ActiveRuleKey.of(XOO_P1_KEY, XOO_X1); ruleActivator.deactivate(key); verifyZeroActiveRules(XOO_P1_KEY); @@ -482,7 +514,7 @@ public class RuleActivatorMediumTest { @Test public void deactivation_fails_if_profile_not_found() { - ActiveRuleKey key = ActiveRuleKey.of("unknown", RuleTesting.XOO_X1); + ActiveRuleKey key = ActiveRuleKey.of("unknown", XOO_X1); try { ruleActivator.deactivate(key); fail(); @@ -494,18 +526,18 @@ public class RuleActivatorMediumTest { @Test public void allow_to_deactivate_removed_rule() { // activation - RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1); + RuleActivation activation = new RuleActivation(XOO_X1); activate(activation, XOO_P1_KEY); // set rule as removed - RuleDto rule = db.deprecatedRuleDao().getByKey(dbSession, RuleTesting.XOO_X1); + RuleDto rule = db.ruleDao().selectOrFailByKey(dbSession, XOO_X1); rule.setStatus(RuleStatus.REMOVED); - db.deprecatedRuleDao().update(dbSession, rule); + db.ruleDao().update(dbSession, rule); dbSession.commit(); dbSession.clearCache(); // deactivation - ruleActivator.deactivate(ActiveRuleKey.of(XOO_P1_KEY, RuleTesting.XOO_X1)); + ruleActivator.deactivate(ActiveRuleKey.of(XOO_P1_KEY, XOO_X1)); verifyZeroActiveRules(XOO_P1_KEY); } @@ -516,24 +548,24 @@ public class RuleActivatorMediumTest { createChildProfiles(); // activate on child profile, but not on root - RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1); - activation.setSeverity(Severity.BLOCKER); + RuleActivation activation = new RuleActivation(XOO_X1); + activation.setSeverity(BLOCKER); activation.setParameter("max", "7"); activate(activation, XOO_P2_KEY); verifyZeroActiveRules(XOO_P1_KEY); - verifyOneActiveRule(XOO_P2_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, null, ImmutableMap.of("max", "7")); - verifyOneActiveRule(XOO_P3_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P2_KEY, XOO_X1, BLOCKER, null, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P3_KEY, XOO_X1, BLOCKER, INHERITED, ImmutableMap.of("max", "7")); // update severity on child - activation = new RuleActivation(RuleTesting.XOO_X1); - activation.setSeverity(Severity.MINOR); + activation = new RuleActivation(XOO_X1); + activation.setSeverity(MINOR); activation.setParameter("max", "77"); activate(activation, XOO_P2_KEY); verifyZeroActiveRules(XOO_P1_KEY); - verifyOneActiveRule(XOO_P2_KEY, RuleTesting.XOO_X1, Severity.MINOR, null, ImmutableMap.of("max", "77")); - verifyOneActiveRule(XOO_P3_KEY, RuleTesting.XOO_X1, Severity.MINOR, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "77")); + verifyOneActiveRuleInDb(XOO_P2_KEY, XOO_X1, MINOR, null, ImmutableMap.of("max", "77")); + verifyOneActiveRuleInDb(XOO_P3_KEY, XOO_X1, MINOR, INHERITED, ImmutableMap.of("max", "77")); } @Test @@ -541,15 +573,15 @@ public class RuleActivatorMediumTest { createChildProfiles(); // activate on root profile - RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1); - activation.setSeverity(Severity.BLOCKER); + RuleActivation activation = new RuleActivation(XOO_X1); + activation.setSeverity(BLOCKER); activation.setParameter("max", "7"); List changes = activate(activation, XOO_P1_KEY); assertThat(changes).hasSize(3); - verifyOneActiveRule(XOO_P1_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, null, ImmutableMap.of("max", "7")); - verifyOneActiveRule(XOO_P2_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "7")); - verifyOneActiveRule(XOO_P3_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P1_KEY, XOO_X1, BLOCKER, null, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P2_KEY, XOO_X1, BLOCKER, INHERITED, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P3_KEY, XOO_X1, BLOCKER, INHERITED, ImmutableMap.of("max", "7")); } @Test @@ -557,43 +589,43 @@ public class RuleActivatorMediumTest { createChildProfiles(); // activate on root profile - RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1); - activation.setSeverity(Severity.BLOCKER); + RuleActivation activation = new RuleActivation(XOO_X1); + activation.setSeverity(BLOCKER); activation.setParameter("max", "7"); activate(activation, XOO_P1_KEY); - verifyOneActiveRule(XOO_P1_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, null, ImmutableMap.of("max", "7")); - verifyOneActiveRule(XOO_P2_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "7")); - verifyOneActiveRule(XOO_P3_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P1_KEY, XOO_X1, BLOCKER, null, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P2_KEY, XOO_X1, BLOCKER, INHERITED, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P3_KEY, XOO_X1, BLOCKER, INHERITED, ImmutableMap.of("max", "7")); // update on parent - activation = new RuleActivation(RuleTesting.XOO_X1); - activation.setSeverity(Severity.INFO); + activation = new RuleActivation(XOO_X1); + activation.setSeverity(INFO); activation.setParameter("max", "8"); activate(activation, XOO_P1_KEY); - verifyOneActiveRule(XOO_P1_KEY, RuleTesting.XOO_X1, Severity.INFO, null, ImmutableMap.of("max", "8")); - verifyOneActiveRule(XOO_P2_KEY, RuleTesting.XOO_X1, Severity.INFO, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "8")); - verifyOneActiveRule(XOO_P3_KEY, RuleTesting.XOO_X1, Severity.INFO, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "8")); + verifyOneActiveRuleInDb(XOO_P1_KEY, XOO_X1, INFO, null, ImmutableMap.of("max", "8")); + verifyOneActiveRuleInDb(XOO_P2_KEY, XOO_X1, INFO, INHERITED, ImmutableMap.of("max", "8")); + verifyOneActiveRuleInDb(XOO_P3_KEY, XOO_X1, INFO, INHERITED, ImmutableMap.of("max", "8")); // update on child -> propagate on grand child only - activation = new RuleActivation(RuleTesting.XOO_X1); - activation.setSeverity(Severity.MINOR); + activation = new RuleActivation(XOO_X1); + activation.setSeverity(MINOR); activation.setParameter("max", "9"); activate(activation, XOO_P2_KEY); - verifyOneActiveRule(XOO_P1_KEY, RuleTesting.XOO_X1, Severity.INFO, null, ImmutableMap.of("max", "8")); - verifyOneActiveRule(XOO_P2_KEY, RuleTesting.XOO_X1, Severity.MINOR, ActiveRuleDto.OVERRIDES, ImmutableMap.of("max", "9")); - verifyOneActiveRule(XOO_P3_KEY, RuleTesting.XOO_X1, Severity.MINOR, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "9")); + verifyOneActiveRuleInDb(XOO_P1_KEY, XOO_X1, INFO, null, ImmutableMap.of("max", "8")); + verifyOneActiveRuleInDb(XOO_P2_KEY, XOO_X1, MINOR, OVERRIDES, ImmutableMap.of("max", "9")); + verifyOneActiveRuleInDb(XOO_P3_KEY, XOO_X1, MINOR, INHERITED, ImmutableMap.of("max", "9")); // update on grand child - activation = new RuleActivation(RuleTesting.XOO_X1); - activation.setSeverity(Severity.BLOCKER); + activation = new RuleActivation(XOO_X1); + activation.setSeverity(BLOCKER); activation.setParameter("max", "10"); activate(activation, XOO_P3_KEY); - verifyOneActiveRule(XOO_P1_KEY, RuleTesting.XOO_X1, Severity.INFO, null, ImmutableMap.of("max", "8")); - verifyOneActiveRule(XOO_P2_KEY, RuleTesting.XOO_X1, Severity.MINOR, ActiveRuleDto.OVERRIDES, ImmutableMap.of("max", "9")); - verifyOneActiveRule(XOO_P3_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, ActiveRuleDto.OVERRIDES, ImmutableMap.of("max", "10")); + verifyOneActiveRuleInDb(XOO_P1_KEY, XOO_X1, INFO, null, ImmutableMap.of("max", "8")); + verifyOneActiveRuleInDb(XOO_P2_KEY, XOO_X1, MINOR, OVERRIDES, ImmutableMap.of("max", "9")); + verifyOneActiveRuleInDb(XOO_P3_KEY, XOO_X1, BLOCKER, OVERRIDES, ImmutableMap.of("max", "10")); } @Test @@ -601,39 +633,39 @@ public class RuleActivatorMediumTest { createChildProfiles(); // activate on root profile P1 - RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1); - activation.setSeverity(Severity.INFO); + RuleActivation activation = new RuleActivation(XOO_X1); + activation.setSeverity(INFO); activation.setParameter("max", "7"); activate(activation, XOO_P1_KEY); - verifyOneActiveRule(XOO_P1_KEY, RuleTesting.XOO_X1, Severity.INFO, null, ImmutableMap.of("max", "7")); - verifyOneActiveRule(XOO_P2_KEY, RuleTesting.XOO_X1, Severity.INFO, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "7")); - verifyOneActiveRule(XOO_P3_KEY, RuleTesting.XOO_X1, Severity.INFO, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P1_KEY, XOO_X1, INFO, null, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P2_KEY, XOO_X1, INFO, INHERITED, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P3_KEY, XOO_X1, INFO, INHERITED, ImmutableMap.of("max", "7")); // override on child P2 - activation = new RuleActivation(RuleTesting.XOO_X1); - activation.setSeverity(Severity.BLOCKER); + activation = new RuleActivation(XOO_X1); + activation.setSeverity(BLOCKER); activation.setParameter("max", "8"); activate(activation, XOO_P2_KEY); - verifyOneActiveRule(XOO_P1_KEY, RuleTesting.XOO_X1, Severity.INFO, null, ImmutableMap.of("max", "7")); - verifyOneActiveRule(XOO_P2_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, ActiveRuleDto.OVERRIDES, ImmutableMap.of("max", "8")); - verifyOneActiveRule(XOO_P3_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "8")); + verifyOneActiveRuleInDb(XOO_P1_KEY, XOO_X1, INFO, null, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P2_KEY, XOO_X1, BLOCKER, OVERRIDES, ImmutableMap.of("max", "8")); + verifyOneActiveRuleInDb(XOO_P3_KEY, XOO_X1, BLOCKER, INHERITED, ImmutableMap.of("max", "8")); // change on parent -> do not propagate on children because they're overriding values - activation = new RuleActivation(RuleTesting.XOO_X1); - activation.setSeverity(Severity.CRITICAL); + activation = new RuleActivation(XOO_X1); + activation.setSeverity(CRITICAL); activation.setParameter("max", "9"); activate(activation, XOO_P1_KEY); - verifyOneActiveRule(XOO_P1_KEY, RuleTesting.XOO_X1, Severity.CRITICAL, null, ImmutableMap.of("max", "9")); - verifyOneActiveRule(XOO_P2_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, ActiveRuleDto.OVERRIDES, ImmutableMap.of("max", "8")); - verifyOneActiveRule(XOO_P3_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "8")); + verifyOneActiveRuleInDb(XOO_P1_KEY, XOO_X1, CRITICAL, null, ImmutableMap.of("max", "9")); + verifyOneActiveRuleInDb(XOO_P2_KEY, XOO_X1, BLOCKER, OVERRIDES, ImmutableMap.of("max", "8")); + verifyOneActiveRuleInDb(XOO_P3_KEY, XOO_X1, BLOCKER, INHERITED, ImmutableMap.of("max", "8")); // reset on parent (use default severity and params) -> do not propagate on children because they're overriding values - activation = new RuleActivation(RuleTesting.XOO_X1).setReset(true); + activation = new RuleActivation(XOO_X1).setReset(true); activate(activation, XOO_P1_KEY); - verifyOneActiveRule(XOO_P1_KEY, RuleTesting.XOO_X1, Severity.MINOR, null, ImmutableMap.of("max", "10")); - verifyOneActiveRule(XOO_P2_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, ActiveRuleDto.OVERRIDES, ImmutableMap.of("max", "8")); - verifyOneActiveRule(XOO_P3_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "8")); + verifyOneActiveRuleInDb(XOO_P1_KEY, XOO_X1, MINOR, null, ImmutableMap.of("max", "10")); + verifyOneActiveRuleInDb(XOO_P2_KEY, XOO_X1, BLOCKER, OVERRIDES, ImmutableMap.of("max", "8")); + verifyOneActiveRuleInDb(XOO_P3_KEY, XOO_X1, BLOCKER, INHERITED, ImmutableMap.of("max", "8")); } @Test @@ -641,22 +673,22 @@ public class RuleActivatorMediumTest { createChildProfiles(); // activate on child profile - RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1); - activation.setSeverity(Severity.INFO); + RuleActivation activation = new RuleActivation(XOO_X1); + activation.setSeverity(INFO); activation.setParameter("max", "7"); activate(activation, XOO_P2_KEY); verifyZeroActiveRules(XOO_P1_KEY); - verifyOneActiveRule(XOO_P2_KEY, RuleTesting.XOO_X1, Severity.INFO, null, ImmutableMap.of("max", "7")); - verifyOneActiveRule(XOO_P3_KEY, RuleTesting.XOO_X1, Severity.INFO, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P2_KEY, XOO_X1, INFO, null, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P3_KEY, XOO_X1, INFO, INHERITED, ImmutableMap.of("max", "7")); // active the same rule on root profile -> mark the child profile as OVERRIDES - activation = new RuleActivation(RuleTesting.XOO_X1); - activation.setSeverity(Severity.MAJOR); + activation = new RuleActivation(XOO_X1); + activation.setSeverity(MAJOR); activation.setParameter("max", "8"); activate(activation, XOO_P1_KEY); - verifyOneActiveRule(XOO_P1_KEY, RuleTesting.XOO_X1, Severity.MAJOR, null, ImmutableMap.of("max", "8")); - verifyOneActiveRule(XOO_P2_KEY, RuleTesting.XOO_X1, Severity.INFO, ActiveRuleDto.OVERRIDES, ImmutableMap.of("max", "7")); - verifyOneActiveRule(XOO_P3_KEY, RuleTesting.XOO_X1, Severity.INFO, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P1_KEY, XOO_X1, MAJOR, null, ImmutableMap.of("max", "8")); + verifyOneActiveRuleInDb(XOO_P2_KEY, XOO_X1, INFO, OVERRIDES, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P3_KEY, XOO_X1, INFO, INHERITED, ImmutableMap.of("max", "7")); } @Test @@ -664,20 +696,20 @@ public class RuleActivatorMediumTest { createChildProfiles(); // activate on root profile - RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1); - activation.setSeverity(Severity.INFO); + RuleActivation activation = new RuleActivation(XOO_X1); + activation.setSeverity(INFO); activation.setParameter("max", "7"); activate(activation, XOO_P1_KEY); - verifyOneActiveRule(XOO_P1_KEY, RuleTesting.XOO_X1, Severity.INFO, null, ImmutableMap.of("max", "7")); - verifyOneActiveRule(XOO_P2_KEY, RuleTesting.XOO_X1, Severity.INFO, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P1_KEY, XOO_X1, INFO, null, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P2_KEY, XOO_X1, INFO, INHERITED, ImmutableMap.of("max", "7")); // override on child P2 with same severity and params -> do nothing (still INHERITED but not OVERRIDDEN) - activation = new RuleActivation(RuleTesting.XOO_X1); - activation.setSeverity(Severity.INFO); + activation = new RuleActivation(XOO_X1); + activation.setSeverity(INFO); activation.setParameter("max", "7"); activate(activation, XOO_P2_KEY); - verifyOneActiveRule(XOO_P1_KEY, RuleTesting.XOO_X1, Severity.INFO, null, ImmutableMap.of("max", "7")); - verifyOneActiveRule(XOO_P2_KEY, RuleTesting.XOO_X1, Severity.INFO, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P1_KEY, XOO_X1, INFO, null, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P2_KEY, XOO_X1, INFO, INHERITED, ImmutableMap.of("max", "7")); } @Test @@ -685,16 +717,16 @@ public class RuleActivatorMediumTest { createChildProfiles(); // activate on root profile - RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1); - activation.setSeverity(Severity.BLOCKER); + RuleActivation activation = new RuleActivation(XOO_X1); + activation.setSeverity(BLOCKER); activation.setParameter("max", "7"); activate(activation, XOO_P1_KEY); - verifyOneActiveRule(XOO_P1_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, null, ImmutableMap.of("max", "7")); - verifyOneActiveRule(XOO_P2_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "7")); - verifyOneActiveRule(XOO_P3_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P1_KEY, XOO_X1, BLOCKER, null, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P2_KEY, XOO_X1, BLOCKER, INHERITED, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P3_KEY, XOO_X1, BLOCKER, INHERITED, ImmutableMap.of("max", "7")); // deactivate on root - ruleActivator.deactivate(ActiveRuleKey.of(XOO_P1_KEY, RuleTesting.XOO_X1)); + ruleActivator.deactivate(ActiveRuleKey.of(XOO_P1_KEY, XOO_X1)); verifyZeroActiveRules(XOO_P1_KEY); verifyZeroActiveRules(XOO_P2_KEY); @@ -706,25 +738,25 @@ public class RuleActivatorMediumTest { createChildProfiles(); // activate on root profile - RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1); - activation.setSeverity(Severity.INFO); + RuleActivation activation = new RuleActivation(XOO_X1); + activation.setSeverity(INFO); activation.setParameter("max", "7"); activate(activation, XOO_P1_KEY); - verifyOneActiveRule(XOO_P1_KEY, RuleTesting.XOO_X1, Severity.INFO, null, ImmutableMap.of("max", "7")); - verifyOneActiveRule(XOO_P2_KEY, RuleTesting.XOO_X1, Severity.INFO, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "7")); - verifyOneActiveRule(XOO_P3_KEY, RuleTesting.XOO_X1, Severity.INFO, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P1_KEY, XOO_X1, INFO, null, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P2_KEY, XOO_X1, INFO, INHERITED, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P3_KEY, XOO_X1, INFO, INHERITED, ImmutableMap.of("max", "7")); // override on child - activation = new RuleActivation(RuleTesting.XOO_X1); - activation.setSeverity(Severity.BLOCKER); + activation = new RuleActivation(XOO_X1); + activation.setSeverity(BLOCKER); activation.setParameter("max", "8"); activate(activation, XOO_P2_KEY); - verifyOneActiveRule(XOO_P1_KEY, RuleTesting.XOO_X1, Severity.INFO, null, ImmutableMap.of("max", "7")); - verifyOneActiveRule(XOO_P2_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, ActiveRuleDto.OVERRIDES, ImmutableMap.of("max", "8")); - verifyOneActiveRule(XOO_P3_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "8")); + verifyOneActiveRuleInDb(XOO_P1_KEY, XOO_X1, INFO, null, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P2_KEY, XOO_X1, BLOCKER, OVERRIDES, ImmutableMap.of("max", "8")); + verifyOneActiveRuleInDb(XOO_P3_KEY, XOO_X1, BLOCKER, INHERITED, ImmutableMap.of("max", "8")); // deactivate on parent -> do not propagate on children because they're overriding values - ruleActivator.deactivate(ActiveRuleKey.of(XOO_P1_KEY, RuleTesting.XOO_X1)); + ruleActivator.deactivate(ActiveRuleKey.of(XOO_P1_KEY, XOO_X1)); dbSession.clearCache(); verifyZeroActiveRules(XOO_P1_KEY); verifyZeroActiveRules(XOO_P2_KEY); @@ -736,17 +768,17 @@ public class RuleActivatorMediumTest { createChildProfiles(); // activate on root profile - RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1); - activation.setSeverity(Severity.BLOCKER); + RuleActivation activation = new RuleActivation(XOO_X1); + activation.setSeverity(BLOCKER); activation.setParameter("max", "7"); activate(activation, XOO_P1_KEY); - verifyOneActiveRule(XOO_P1_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, null, ImmutableMap.of("max", "7")); - verifyOneActiveRule(XOO_P2_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "7")); - verifyOneActiveRule(XOO_P3_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P1_KEY, XOO_X1, BLOCKER, null, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P2_KEY, XOO_X1, BLOCKER, INHERITED, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P3_KEY, XOO_X1, BLOCKER, INHERITED, ImmutableMap.of("max", "7")); // try to deactivate on child try { - ruleActivator.deactivate(ActiveRuleKey.of(XOO_P2_KEY, RuleTesting.XOO_X1)); + ruleActivator.deactivate(ActiveRuleKey.of(XOO_P2_KEY, XOO_X1)); fail(); } catch (BadRequestException e) { assertThat(e).hasMessage("Cannot deactivate inherited rule 'xoo:x1'"); @@ -758,29 +790,29 @@ public class RuleActivatorMediumTest { createChildProfiles(); // activate on root profile - RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1); - activation.setSeverity(Severity.BLOCKER); + RuleActivation activation = new RuleActivation(XOO_X1); + activation.setSeverity(BLOCKER); activation.setParameter("max", "7"); activate(activation, XOO_P1_KEY); - verifyOneActiveRule(XOO_P1_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, null, ImmutableMap.of("max", "7")); - verifyOneActiveRule(XOO_P2_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "7")); - verifyOneActiveRule(XOO_P3_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P1_KEY, XOO_X1, BLOCKER, null, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P2_KEY, XOO_X1, BLOCKER, INHERITED, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P3_KEY, XOO_X1, BLOCKER, INHERITED, ImmutableMap.of("max", "7")); // override - activation = new RuleActivation(RuleTesting.XOO_X1); - activation.setSeverity(Severity.INFO); + activation = new RuleActivation(XOO_X1); + activation.setSeverity(INFO); activation.setParameter("max", "10"); activate(activation, XOO_P2_KEY); - verifyOneActiveRule(XOO_P1_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, null, ImmutableMap.of("max", "7")); - verifyOneActiveRule(XOO_P2_KEY, RuleTesting.XOO_X1, Severity.INFO, ActiveRuleDto.OVERRIDES, ImmutableMap.of("max", "10")); - verifyOneActiveRule(XOO_P3_KEY, RuleTesting.XOO_X1, Severity.INFO, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "10")); + verifyOneActiveRuleInDb(XOO_P1_KEY, XOO_X1, BLOCKER, null, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P2_KEY, XOO_X1, INFO, OVERRIDES, ImmutableMap.of("max", "10")); + verifyOneActiveRuleInDb(XOO_P3_KEY, XOO_X1, INFO, INHERITED, ImmutableMap.of("max", "10")); // reset -> remove overridden values - activation = new RuleActivation(RuleTesting.XOO_X1).setReset(true); + activation = new RuleActivation(XOO_X1).setReset(true); activate(activation, XOO_P2_KEY); - verifyOneActiveRule(XOO_P1_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, null, ImmutableMap.of("max", "7")); - verifyOneActiveRule(XOO_P2_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "7")); - verifyOneActiveRule(XOO_P3_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P1_KEY, XOO_X1, BLOCKER, null, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P2_KEY, XOO_X1, BLOCKER, INHERITED, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P3_KEY, XOO_X1, BLOCKER, INHERITED, ImmutableMap.of("max", "7")); } @Test @@ -788,44 +820,44 @@ public class RuleActivatorMediumTest { createChildProfiles(); // activate on root profile - RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1); - activation.setSeverity(Severity.BLOCKER); + RuleActivation activation = new RuleActivation(XOO_X1); + activation.setSeverity(BLOCKER); activation.setParameter("max", "7"); activate(activation, XOO_P1_KEY); - verifyOneActiveRule(XOO_P1_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, null, ImmutableMap.of("max", "7")); - verifyOneActiveRule(XOO_P2_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "7")); - verifyOneActiveRule(XOO_P3_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P1_KEY, XOO_X1, BLOCKER, null, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P2_KEY, XOO_X1, BLOCKER, INHERITED, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P3_KEY, XOO_X1, BLOCKER, INHERITED, ImmutableMap.of("max", "7")); // override on child - activation = new RuleActivation(RuleTesting.XOO_X1); - activation.setSeverity(Severity.INFO); + activation = new RuleActivation(XOO_X1); + activation.setSeverity(INFO); activation.setParameter("max", "10"); activate(activation, XOO_P2_KEY); - verifyOneActiveRule(XOO_P1_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, null, ImmutableMap.of("max", "7")); - verifyOneActiveRule(XOO_P2_KEY, RuleTesting.XOO_X1, Severity.INFO, ActiveRuleDto.OVERRIDES, ImmutableMap.of("max", "10")); - verifyOneActiveRule(XOO_P3_KEY, RuleTesting.XOO_X1, Severity.INFO, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "10")); + verifyOneActiveRuleInDb(XOO_P1_KEY, XOO_X1, BLOCKER, null, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P2_KEY, XOO_X1, INFO, OVERRIDES, ImmutableMap.of("max", "10")); + verifyOneActiveRuleInDb(XOO_P3_KEY, XOO_X1, INFO, INHERITED, ImmutableMap.of("max", "10")); // override on grand child - activation = new RuleActivation(RuleTesting.XOO_X1); - activation.setSeverity(Severity.MINOR); + activation = new RuleActivation(XOO_X1); + activation.setSeverity(MINOR); activation.setParameter("max", "20"); activate(activation, XOO_P3_KEY); - verifyOneActiveRule(XOO_P1_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, null, ImmutableMap.of("max", "7")); - verifyOneActiveRule(XOO_P2_KEY, RuleTesting.XOO_X1, Severity.INFO, ActiveRuleDto.OVERRIDES, ImmutableMap.of("max", "10")); - verifyOneActiveRule(XOO_P3_KEY, RuleTesting.XOO_X1, Severity.MINOR, ActiveRuleDto.OVERRIDES, ImmutableMap.of("max", "20")); + verifyOneActiveRuleInDb(XOO_P1_KEY, XOO_X1, BLOCKER, null, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P2_KEY, XOO_X1, INFO, OVERRIDES, ImmutableMap.of("max", "10")); + verifyOneActiveRuleInDb(XOO_P3_KEY, XOO_X1, MINOR, OVERRIDES, ImmutableMap.of("max", "20")); // reset child P2 -> keep the overridden grand-child P3 - activation = new RuleActivation(RuleTesting.XOO_X1).setReset(true); + activation = new RuleActivation(XOO_X1).setReset(true); activate(activation, XOO_P2_KEY); - verifyOneActiveRule(XOO_P1_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, null, ImmutableMap.of("max", "7")); - verifyOneActiveRule(XOO_P2_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "7")); - verifyOneActiveRule(XOO_P3_KEY, RuleTesting.XOO_X1, Severity.MINOR, ActiveRuleDto.OVERRIDES, ImmutableMap.of("max", "20")); + verifyOneActiveRuleInDb(XOO_P1_KEY, XOO_X1, BLOCKER, null, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P2_KEY, XOO_X1, BLOCKER, INHERITED, ImmutableMap.of("max", "7")); + verifyOneActiveRuleInDb(XOO_P3_KEY, XOO_X1, MINOR, OVERRIDES, ImmutableMap.of("max", "20")); } @Test public void ignore_reset_if_not_activated() { createChildProfiles(); - RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1).setReset(true); + RuleActivation activation = new RuleActivation(XOO_X1).setReset(true); activate(activation, XOO_P1_KEY); verifyZeroActiveRules(XOO_P1_KEY); @@ -837,14 +869,15 @@ public class RuleActivatorMediumTest { // Generate more rules than the search's max limit int bulkSize = QueryContext.MAX_LIMIT + 10; for (int i = 0; i < bulkSize; i++) { - db.deprecatedRuleDao().insert(dbSession, RuleTesting.newDto(RuleKey.of("bulk", "r_" + i)).setLanguage("xoo")); + db.ruleDao().insert(dbSession, newDto(RuleKey.of("bulk", "r_" + i)).setLanguage("xoo")); } dbSession.commit(); + ruleIndexer.index(); // 0. No active rules so far (base case) and plenty rules available verifyZeroActiveRules(XOO_P1_KEY); - assertThat(tester.get(RuleIndex.class) - .search(new RuleQuery().setRepositories(Arrays.asList("bulk")), new QueryContext(userSessionRule)).getTotal()) + assertThat(tester.get(RuleIndex2.class) + .search(new RuleQuery().setRepositories(Arrays.asList("bulk")), new SearchOptions()).getTotal()) .isEqualTo(bulkSize); // 1. bulk activate all the rules @@ -853,8 +886,8 @@ public class RuleActivatorMediumTest { // 2. assert that all activation has been commit to DB and ES dbSession.clearCache(); - assertThat(db.deprecatedActiveRuleDao().selectByProfileKey(dbSession, XOO_P1_KEY)).hasSize(bulkSize); - assertThat(index.findByProfile(XOO_P1_KEY)).hasSize(bulkSize); + assertThat(db.activeRuleDao().selectByProfileKey(dbSession, XOO_P1_KEY)).hasSize(bulkSize); + assertThat(activeRuleIndex.findByProfile(XOO_P1_KEY)).hasSize(bulkSize); assertThat(result.countSucceeded()).isEqualTo(bulkSize); assertThat(result.countFailed()).isEqualTo(0); } @@ -867,24 +900,23 @@ public class RuleActivatorMediumTest { // 2. assert that all activations have been commit to DB and ES // -> xoo rules x1, x2 and custom1 dbSession.clearCache(); - assertThat(db.deprecatedActiveRuleDao().selectByProfileKey(dbSession, XOO_P1_KEY)).hasSize(3); - assertThat(index.findByProfile(XOO_P1_KEY)).hasSize(3); + assertThat(db.activeRuleDao().selectByProfileKey(dbSession, XOO_P1_KEY)).hasSize(3); + assertThat(activeRuleIndex.findByProfile(XOO_P1_KEY)).hasSize(3); assertThat(result.countSucceeded()).isEqualTo(3); assertThat(result.countFailed()).isGreaterThan(0); - } @Test public void set_and_unset_parent_profile() { // x1 is activated on the "future parent" P1 - RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1); + RuleActivation activation = new RuleActivation(XOO_X1); activation.setSeverity("MAJOR"); activate(activation, XOO_P1_KEY); - verifyOneActiveRule(XOO_P1_KEY, RuleTesting.XOO_X1, Severity.MAJOR, null, ImmutableMap.of("max", "10")); + verifyOneActiveRuleInDb(XOO_P1_KEY, XOO_X1, MAJOR, null, ImmutableMap.of("max", "10")); // create profile P2 with x2 db.qualityProfileDao().insert(dbSession, QProfileTesting.newXooP2()); - activation = new RuleActivation(RuleTesting.XOO_X2); + activation = new RuleActivation(XOO_X2); activation.setSeverity("MAJOR"); activate(activation, XOO_P2_KEY); @@ -892,15 +924,16 @@ public class RuleActivatorMediumTest { ruleActivator.setParent(XOO_P2_KEY, XOO_P1_KEY); dbSession.clearCache(); assertThat(db.qualityProfileDao().selectByKey(dbSession, XOO_P2_KEY).getParentKee()).isEqualTo(XOO_P1_KEY); - verifyHasActiveRule(ActiveRuleKey.of(XOO_P2_KEY, RuleTesting.XOO_X1), Severity.MAJOR, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "10")); - verifyHasActiveRule(ActiveRuleKey.of(XOO_P2_KEY, RuleTesting.XOO_X2), Severity.MAJOR, null, Collections.emptyMap()); + + verifyHasActiveRuleInDbAndIndex(ActiveRuleKey.of(XOO_P2_KEY, XOO_X1), MAJOR, INHERITED, ImmutableMap.of("max", "10")); + verifyHasActiveRuleInDbAndIndex(ActiveRuleKey.of(XOO_P2_KEY, XOO_X2), MAJOR, null, Collections.emptyMap()); // unset parent dbSession.clearCache(); ruleActivator.setParent(XOO_P2_KEY, null); assertThat(countActiveRules(XOO_P2_KEY)).isEqualTo(1); assertThat(db.qualityProfileDao().selectByKey(dbSession, XOO_P2_KEY).getParentKee()).isNull(); - verifyHasActiveRule(ActiveRuleKey.of(XOO_P2_KEY, RuleTesting.XOO_X2), Severity.MAJOR, null, Collections.emptyMap()); + verifyHasActiveRuleInDbAndIndex(ActiveRuleKey.of(XOO_P2_KEY, XOO_X2), MAJOR, null, Collections.emptyMap()); } @Test @@ -925,10 +958,10 @@ public class RuleActivatorMediumTest { @Test public void keep_overridden_rules_when_unsetting_parent() { // x1 is activated on the "future parent" - RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1); + RuleActivation activation = new RuleActivation(XOO_X1); activation.setSeverity("MAJOR"); activate(activation, XOO_P1_KEY); - verifyOneActiveRule(XOO_P1_KEY, RuleTesting.XOO_X1, Severity.MAJOR, null, ImmutableMap.of("max", "10")); + verifyOneActiveRuleInDb(XOO_P1_KEY, XOO_X1, MAJOR, null, ImmutableMap.of("max", "10")); // create empty profile P2 db.qualityProfileDao().insert(dbSession, QProfileTesting.newXooP2()); @@ -937,36 +970,36 @@ public class RuleActivatorMediumTest { // set parent -> child profile inherits rule x1 ruleActivator.setParent(XOO_P2_KEY, XOO_P1_KEY); - verifyOneActiveRule(XOO_P2_KEY, RuleTesting.XOO_X1, Severity.MAJOR, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "10")); + verifyOneActiveRuleInDbAndIndex(XOO_P2_KEY, XOO_X1, MAJOR, INHERITED, ImmutableMap.of("max", "10")); // override x1 - activation = new RuleActivation(RuleTesting.XOO_X1); + activation = new RuleActivation(XOO_X1); activation.setSeverity("BLOCKER").setParameter("max", "333"); activate(activation, XOO_P2_KEY); - verifyOneActiveRule(XOO_P2_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, ActiveRuleDto.OVERRIDES, ImmutableMap.of("max", "333")); + verifyOneActiveRuleInDb(XOO_P2_KEY, XOO_X1, BLOCKER, OVERRIDES, ImmutableMap.of("max", "333")); // unset parent -> keep x1 ruleActivator.setParent(XOO_P2_KEY, null); dbSession.clearCache(); assertThat(db.qualityProfileDao().selectByKey(dbSession, XOO_P2_KEY).getParentKee()).isNull(); - verifyOneActiveRule(XOO_P2_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, null, ImmutableMap.of("max", "333")); + verifyOneActiveRuleInDbAndIndex(XOO_P2_KEY, XOO_X1, BLOCKER, null, ImmutableMap.of("max", "333")); } @Test public void ignore_activation_errors_when_setting_parent() { // x1 and x2 are activated on the "future parent" P1 - RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1).setSeverity("MAJOR"); + RuleActivation activation = new RuleActivation(XOO_X1).setSeverity("MAJOR"); activate(activation, XOO_P1_KEY); - activation = new RuleActivation(RuleTesting.XOO_X2).setSeverity("MAJOR"); + activation = new RuleActivation(XOO_X2).setSeverity("MAJOR"); activate(activation, XOO_P1_KEY); // create profile P2 db.qualityProfileDao().insert(dbSession, QProfileTesting.newXooP2()); // mark rule x1 as REMOVED - RuleDto rule = db.deprecatedRuleDao().getByKey(dbSession, RuleTesting.XOO_X1); + RuleDto rule = db.ruleDao().selectOrFailByKey(dbSession, XOO_X1); rule.setStatus(RuleStatus.REMOVED); - db.deprecatedRuleDao().update(dbSession, rule); + db.ruleDao().update(dbSession, rule); dbSession.commit(); dbSession.clearCache(); @@ -976,13 +1009,13 @@ public class RuleActivatorMediumTest { assertThat(db.qualityProfileDao().selectByKey(dbSession, XOO_P2_KEY).getParentKee()).isEqualTo(XOO_P1_KEY); assertThat(countActiveRules(XOO_P2_KEY)).isEqualTo(1); - verifyHasActiveRule(ActiveRuleKey.of(XOO_P2_KEY, RuleTesting.XOO_X2), Severity.MAJOR, ActiveRuleDto.INHERITED, Collections.emptyMap()); + verifyHasActiveRuleInDbAndIndex(ActiveRuleKey.of(XOO_P2_KEY, XOO_X2), MAJOR, INHERITED, Collections.emptyMap()); } @Test public void bulk_deactivate() { - activate(new RuleActivation(RuleTesting.XOO_X1), XOO_P1_KEY); - activate(new RuleActivation(RuleTesting.XOO_X2), XOO_P1_KEY); + activate(new RuleActivation(XOO_X1), XOO_P1_KEY); + activate(new RuleActivation(XOO_X2), XOO_P1_KEY); assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(2); BulkChangeResult result = ruleActivator.bulkDeactivate(new RuleQuery().setActivation(true).setQProfileKey(XOO_P1_KEY), XOO_P1_KEY); @@ -998,7 +1031,7 @@ public class RuleActivatorMediumTest { public void bulk_deactivation_ignores_errors() { // activate on parent profile P1 createChildProfiles(); - activate(new RuleActivation(RuleTesting.XOO_X1), XOO_P1_KEY); + activate(new RuleActivation(XOO_X1), XOO_P1_KEY); assertThat(countActiveRules(XOO_P2_KEY)).isEqualTo(1); // bulk deactivate on child profile P2 -> not possible @@ -1016,9 +1049,9 @@ public class RuleActivatorMediumTest { createChildProfiles(); // activate two rules on root profile P1 (propagated to P2 and P3) - RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1).setSeverity(Severity.INFO).setParameter("max", "7"); + RuleActivation activation = new RuleActivation(XOO_X1).setSeverity(INFO).setParameter("max", "7"); activate(activation, XOO_P1_KEY); - activation = new RuleActivation(RuleTesting.XOO_X2).setSeverity(Severity.INFO); + activation = new RuleActivation(XOO_X2).setSeverity(INFO); activate(activation, XOO_P1_KEY); // bulk change severity to BLOCKER. Parameters are not set. @@ -1026,81 +1059,83 @@ public class RuleActivatorMediumTest { BulkChangeResult result = ruleActivator.bulkActivate(query, XOO_P1_KEY, "BLOCKER"); assertThat(result.countSucceeded()).isEqualTo(2); - verifyHasActiveRule(XOO_P1_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, null, ImmutableMap.of("max", "7")); - verifyHasActiveRule(XOO_P1_KEY, RuleTesting.XOO_X2, Severity.BLOCKER, null, Collections.emptyMap()); - verifyHasActiveRule(XOO_P2_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "7")); - verifyHasActiveRule(XOO_P2_KEY, RuleTesting.XOO_X2, Severity.BLOCKER, ActiveRuleDto.INHERITED, Collections.emptyMap()); - verifyHasActiveRule(XOO_P3_KEY, RuleTesting.XOO_X1, Severity.BLOCKER, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "7")); - verifyHasActiveRule(XOO_P3_KEY, RuleTesting.XOO_X2, Severity.BLOCKER, ActiveRuleDto.INHERITED, Collections.emptyMap()); + verifyHasActiveRuleInDbAndIndex(ActiveRuleKey.of(XOO_P1_KEY, XOO_X1), BLOCKER, null, ImmutableMap.of("max", "7")); + verifyHasActiveRuleInDbAndIndex(ActiveRuleKey.of(XOO_P1_KEY, XOO_X2), BLOCKER, null, Collections.emptyMap()); + verifyHasActiveRuleInDbAndIndex(ActiveRuleKey.of(XOO_P2_KEY, XOO_X1), BLOCKER, INHERITED, ImmutableMap.of("max", "7")); + verifyHasActiveRuleInDbAndIndex(ActiveRuleKey.of(XOO_P2_KEY, XOO_X2), BLOCKER, INHERITED, Collections.emptyMap()); + verifyHasActiveRuleInDbAndIndex(ActiveRuleKey.of(XOO_P3_KEY, XOO_X1), BLOCKER, INHERITED, ImmutableMap.of("max", "7")); + verifyHasActiveRuleInDbAndIndex(ActiveRuleKey.of(XOO_P3_KEY, XOO_X2), BLOCKER, INHERITED, Collections.emptyMap()); } private int countActiveRules(String profileKey) { - List activeRuleDtos = db.deprecatedActiveRuleDao().selectByProfileKey(dbSession, profileKey); - List activeRules = Lists.newArrayList(index.findByProfile(profileKey)); - assertThat(activeRuleDtos.size()).as("Not same active rules between db and index").isEqualTo(activeRules.size()); + List activeRuleDtos = db.activeRuleDao().selectByProfileKey(dbSession, profileKey); return activeRuleDtos.size(); } - private void verifyOneActiveRule(String profileKey, RuleKey ruleKey, String expectedSeverity, + private void verifyOneActiveRuleInDb(String profileKey, RuleKey ruleKey, String expectedSeverity, @Nullable String expectedInheritance, Map expectedParams) { assertThat(countActiveRules(profileKey)).isEqualTo(1); - verifyHasActiveRule(profileKey, ruleKey, expectedSeverity, expectedInheritance, expectedParams); + verifyHasActiveRuleInDb(ActiveRuleKey.of(profileKey, ruleKey), expectedSeverity, expectedInheritance, expectedParams); } - private void verifyHasActiveRule(String profileKey, RuleKey ruleKey, String expectedSeverity, + private void verifyOneActiveRuleInDbAndIndex(String profileKey, RuleKey ruleKey, String expectedSeverity, @Nullable String expectedInheritance, Map expectedParams) { - verifyHasActiveRule(ActiveRuleKey.of(profileKey, ruleKey), expectedSeverity, expectedInheritance, expectedParams); + assertThat(countActiveRules(profileKey)).isEqualTo(1); + verifyHasActiveRuleInDbAndIndex(ActiveRuleKey.of(profileKey, ruleKey), expectedSeverity, expectedInheritance, expectedParams); } - private void verifyHasActiveRule(ActiveRuleKey activeRuleKey, String expectedSeverity, + private void verifyHasActiveRuleInDb(ActiveRuleKey activeRuleKey, String expectedSeverity, @Nullable String expectedInheritance, Map expectedParams) { // verify db boolean found = false; - List activeRuleDtos = db.deprecatedActiveRuleDao().selectByProfileKey(dbSession, activeRuleKey.qProfile()); + List activeRuleDtos = db.activeRuleDao().selectByProfileKey(dbSession, activeRuleKey.qProfile()); for (ActiveRuleDto activeRuleDto : activeRuleDtos) { if (activeRuleDto.getKey().equals(activeRuleKey)) { found = true; assertThat(activeRuleDto.getSeverityString()).isEqualTo(expectedSeverity); assertThat(activeRuleDto.getInheritance()).isEqualTo(expectedInheritance); // Dates should be set - assertThat(activeRuleDto.getCreatedAt()).isNotNull(); - assertThat(activeRuleDto.getUpdatedAt()).isNotNull(); + assertThat(activeRuleDto.getCreatedAtInMs()).isNotNull(); + assertThat(activeRuleDto.getUpdatedAtInMs()).isNotNull(); - List paramDtos = db.deprecatedActiveRuleDao().selectParamsByActiveRuleKey(dbSession, activeRuleDto.getKey()); + List paramDtos = db.activeRuleDao().selectParamsByActiveRuleKey(dbSession, activeRuleDto.getKey()); assertThat(paramDtos).hasSize(expectedParams.size()); for (Map.Entry entry : expectedParams.entrySet()) { - ActiveRuleParamDto paramDto = db.deprecatedActiveRuleDao().selectParamByKeyAndName(activeRuleDto.getKey(), entry.getKey(), dbSession); + ActiveRuleParamDto paramDto = db.activeRuleDao().selectParamByKeyAndName(activeRuleDto.getKey(), entry.getKey(), dbSession); assertThat(paramDto).isNotNull(); assertThat(paramDto.getValue()).isEqualTo(entry.getValue()); } } } assertThat(found).as("Rule is not activated in db").isTrue(); + } + private void verifyHasActiveRuleInIndex(ActiveRuleKey activeRuleKey, String expectedSeverity, + @Nullable String expectedInheritance) { // verify es - List activeRules = Lists.newArrayList(index.findByProfile(activeRuleKey.qProfile())); - found = false; - for (ActiveRule activeRule : activeRules) { + List activeRules = Lists.newArrayList(activeRuleIndex.findByProfile(activeRuleKey.qProfile())); + boolean found = false; + for (ActiveRuleDoc activeRule : activeRules) { if (activeRule.key().equals(activeRuleKey)) { found = true; assertThat(activeRule.severity()).isEqualTo(expectedSeverity); - assertThat(activeRule.inheritance()).isEqualTo(expectedInheritance == null ? ActiveRule.Inheritance.NONE : ActiveRule.Inheritance.valueOf(expectedInheritance)); + assertThat(activeRule.inheritance()).isEqualTo(expectedInheritance == null ? ActiveRule.Inheritance.NONE : + ActiveRule.Inheritance.valueOf(expectedInheritance)); // Dates should be set - assertThat(activeRule.createdAt()).isNotNull(); - assertThat(activeRule.updatedAt()).isNotNull(); - - // verify parameters in es - assertThat(activeRule.params()).hasSize(expectedParams.size()); - for (Map.Entry entry : expectedParams.entrySet()) { - String value = activeRule.params().get(entry.getKey()); - assertThat(value).isEqualTo(entry.getValue()); - } + assertThat(activeRule.createdAtAsLong()).isNotNull(); + assertThat(activeRule.updatedAtAsLong()).isNotNull(); } } assertThat(found).as("Rule is not activated in index").isTrue(); } + private void verifyHasActiveRuleInDbAndIndex(ActiveRuleKey activeRuleKey, String expectedSeverity, + @Nullable String expectedInheritance, Map expectedParams) { + verifyHasActiveRuleInDb(activeRuleKey, expectedSeverity, expectedInheritance, expectedParams); + verifyHasActiveRuleInIndex(activeRuleKey, expectedSeverity, expectedInheritance); + } + private void createChildProfiles() { db.qualityProfileDao().insert(dbSession, QProfileTesting.newXooP2().setParentKee(XOO_P1_KEY)); db.qualityProfileDao().insert(dbSession, QProfileTesting.newXooP3().setParentKee(XOO_P2_KEY)); @@ -1111,17 +1146,18 @@ public class RuleActivatorMediumTest { List changes = ruleActivator.activate(dbSession, activation, profileKey); dbSession.commit(); dbSession.clearCache(); + activeRuleIndexer.index(changes); return changes; } private void verifyZeroActiveRules(String key) { // verify db dbSession.clearCache(); - List activeRuleDtos = db.deprecatedActiveRuleDao().selectByProfileKey(dbSession, key); + List activeRuleDtos = db.activeRuleDao().selectByProfileKey(dbSession, key); assertThat(activeRuleDtos).isEmpty(); // verify es - List activeRules = Lists.newArrayList(index.findByProfile(key)); + List activeRules = Lists.newArrayList(activeRuleIndex.findByProfile(key)); assertThat(activeRules).isEmpty(); } } -- 2.39.5