import it.duplication.CrossProjectDuplicationsTest;
import it.duplication.DuplicationsTest;
import it.duplication.NewDuplicationsTest;
+import it.organization.RootUserTest;
import it.projectEvent.EventTest;
import it.projectEvent.ProjectActivityPageTest;
import it.qualityProfile.QualityProfilesPageTest;
@RunWith(Suite.class)
@Suite.SuiteClasses({
+ // organization
+ RootUserTest.class,
// server system
ServerSystemTest.class,
PingTest.class,
*/
package it;
-import it.organization.RootTest;
import it.serverSystem.ClusterTest;
import it.serverSystem.RestartTest;
import it.serverSystem.ServerSystemRestartingOrchestrator;
// update center
UpdateCenterTest.class,
RealmAuthenticationTest.class,
- SsoAuthenticationTest.class,
- RootTest.class
+ SsoAuthenticationTest.class
})
public class Category5Suite {
package it;
import com.sonar.orchestrator.Orchestrator;
+import com.sonar.orchestrator.http.HttpMethod;
import it.issue.IssueTagsTest;
import it.issue.OrganizationIssueAssignTest;
import it.organization.BillingTest;
import it.organization.OrganizationTest;
import it.projectSearch.LeakProjectsPageTest;
import it.projectSearch.SearchProjectsTest;
+import it.organization.RootUserOnOrganizationTest;
import it.qualityProfile.OrganizationQualityProfilesPageTest;
import it.qualityProfile.QualityProfilesBuiltInTest;
import it.uiExtension.OrganizationUiExtensionsTest;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
-import static java.util.Collections.emptyMap;
import static util.ItUtils.pluginArtifact;
import static util.ItUtils.xooPlugin;
OrganizationMembershipTest.class,
OrganizationQualityProfilesPageTest.class,
OrganizationTest.class,
+ RootUserOnOrganizationTest.class,
OrganizationUiExtensionsTest.class,
QualityProfilesBuiltInTest.class,
BillingTest.class,
}
public static void enableOrganizationsSupport() {
- ORCHESTRATOR.getServer().post("api/organizations/enable_support", emptyMap());
+ ORCHESTRATOR.getServer()
+ .newHttpCall("api/organizations/enable_support")
+ .setMethod(HttpMethod.POST)
+ .setAdminCredentials()
+ .execute();
}
}
import static java.lang.String.format;
import static java.util.Collections.singletonList;
import static org.assertj.core.api.Assertions.assertThat;
-import static util.ItUtils.deleteOrganizationsIfExists;
+import static util.ItUtils.deleteOrganizations;
import static util.ItUtils.newAdminWsClient;
import static util.ItUtils.newOrganizationKey;
import static util.ItUtils.restoreProfile;
@After
public void tearDown() throws Exception {
userRule.deactivateUsers(ASSIGNEE_LOGIN, OTHER_LOGIN);
- deleteOrganizationsIfExists(orchestrator, ORGANIZATION_KEY, OTHER_ORGANIZATION_KEY);
+ deleteOrganizations(orchestrator);
}
@Test
import static it.Category6Suite.enableOrganizationsSupport;
import static org.apache.commons.lang.RandomStringUtils.randomAlphabetic;
import static org.assertj.core.api.Assertions.assertThat;
-import static util.ItUtils.deleteOrganizationsIfExists;
+import static util.ItUtils.deleteOrganizations;
import static util.ItUtils.newAdminWsClient;
import static util.ItUtils.newOrganizationKey;
import static util.ItUtils.newUserWsClient;
adminClient = newAdminWsClient(orchestrator);
enableOrganizationsSupport();
setServerProperty(orchestrator, "sonar.organizations.anyoneCanCreate", "true");
- deleteOrganizationsIfExists(orchestrator, KEY);
+ deleteOrganizations(orchestrator);
}
@After
public void tearDown() throws Exception {
- deleteOrganizationsIfExists(orchestrator, KEY);
+ deleteOrganizations(orchestrator);
}
@Test
import static org.apache.commons.lang.RandomStringUtils.randomAlphabetic;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.fail;
-import static util.ItUtils.deleteOrganizationsIfExists;
+import static util.ItUtils.deleteOrganizations;
import static util.ItUtils.newAdminWsClient;
import static util.ItUtils.newUserWsClient;
import static util.ItUtils.newWsClient;
@Before
public void setUp() throws Exception {
resetSettings(orchestrator, null, SETTING_ANYONE_CAN_CREATE_ORGANIZATIONS);
- deleteOrganizationsIfExists(orchestrator, KEY, "an-org");
+ deleteOrganizations(orchestrator);
userRule.deactivateUsers(USER_LOGIN);
}
@After
public void tearDown() throws Exception {
- deleteOrganizationsIfExists(orchestrator, KEY, "an-org");
+ deleteOrganizations(orchestrator);
}
@Test
@Test
public void an_organization_member_can_analyze_project() {
+
assertThatOrganizationDoesNotExit(KEY);
Organizations.Organization createdOrganization = adminOrganizationService.create(new CreateWsRequest.Builder()
for (QualityProfiles.SearchWsResponse.QualityProfile profile : response.getProfilesList()) {
assertThat(profile.getIsInherited()).isFalse();
assertThat(profile.getProjectCount()).isEqualTo(0);
+ assertThat(profile.getIsBuiltIn()).isTrue();
if (profile.getName().toLowerCase(Locale.ENGLISH).contains("empty")) {
assertThat(profile.getActiveRuleCount()).isEqualTo(0);
} else {
assertThat(profile.getActiveRuleCount()).isGreaterThan(0);
// that allows to check the Elasticsearch index of active rules
Rules.SearchResponse activeRulesResponse = adminClient.rules().search(new org.sonarqube.ws.client.rule.SearchWsRequest().setActivation(true).setQProfile(profile.getKey()));
- assertThat(activeRulesResponse.getTotal()).isEqualTo(profile.getActiveRuleCount());
+ assertThat(activeRulesResponse.getTotal()).as("profile " + profile.getName()).isEqualTo(profile.getActiveRuleCount());
assertThat(activeRulesResponse.getRulesCount()).isEqualTo((int)profile.getActiveRuleCount());
}
}
+++ /dev/null
-/*
- * SonarQube
- * Copyright (C) 2009-2017 SonarSource SA
- * mailto:info AT sonarsource DOT com
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 3 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-package it.organization;
-
-import com.sonar.orchestrator.Orchestrator;
-import java.sql.SQLException;
-import java.util.Collections;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.sonarqube.ws.WsRoot;
-import org.sonarqube.ws.client.HttpException;
-import org.sonarqube.ws.client.WsClient;
-import util.user.UserRule;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.fail;
-import static util.ItUtils.newAdminWsClient;
-import static util.ItUtils.newUserWsClient;
-import static util.ItUtils.newWsClient;
-
-public class RootTest {
-
- private static Orchestrator orchestrator;
-
- private static UserRule userRule;
-
- @Before
- public void start() {
- orchestrator = Orchestrator.builderEnv().build();
- orchestrator.start();
- userRule = UserRule.from(orchestrator);
- }
-
- @After
- public void stop() {
- if (orchestrator != null) {
- orchestrator.stop();
- userRule = null;
- }
- }
-
- @Test
- public void nobody_is_root_by_default() {
- // anonymous
- verifyHttpError(() -> newWsClient(orchestrator).rootService().search(), 403);
-
- // admin
- verifyHttpError(() -> newAdminWsClient(orchestrator).rootService().search(), 403);
- }
-
- @Test
- public void system_administrator_is_flagged_as_root_when_he_enables_organization_support() {
- enableOrganizationSupport();
- assertThat(newAdminWsClient(orchestrator).rootService().search().getRootsList())
- .extracting(WsRoot.Root::getLogin)
- .containsOnly(UserRule.ADMIN_LOGIN);
- }
-
- @Test
- public void a_root_can_flag_other_user_as_root() {
- enableOrganizationSupport();
- userRule.createUser("bar", "foo");
- userRule.setRoot("bar");
-
- assertThat(newAdminWsClient(orchestrator).rootService().search().getRootsList())
- .extracting(WsRoot.Root::getLogin)
- .containsOnly(UserRule.ADMIN_LOGIN, "bar");
- }
-
- @Test
- public void last_root_can_not_be_unset_root() throws SQLException {
- enableOrganizationSupport();
- verifyHttpError(() -> newAdminWsClient(orchestrator).rootService().unsetRoot(UserRule.ADMIN_LOGIN), 400);
- }
-
- @Test
- public void root_can_be_set_and_unset_via_web_services() {
- enableOrganizationSupport();
- userRule.createUser("root1", "bar");
- userRule.createUser("root2", "bar");
- WsClient root1WsClient = newUserWsClient(orchestrator, "root1", "bar");
- WsClient root2WsClient = newUserWsClient(orchestrator, "root2", "bar");
-
- // non root can not set or unset root another user not itself
- verifyHttpError(() -> root1WsClient.rootService().setRoot("root2"), 403);
- verifyHttpError(() -> root1WsClient.rootService().setRoot("root1"), 403);
- verifyHttpError(() -> root1WsClient.rootService().unsetRoot("root1"), 403);
- verifyHttpError(() -> root2WsClient.rootService().unsetRoot("root1"), 403);
- verifyHttpError(() -> root2WsClient.rootService().unsetRoot("root2"), 403);
- // admin (the first root) sets root1 as root
- newAdminWsClient(orchestrator).rootService().setRoot("root1");
- // root1 can set root root2
- root1WsClient.rootService().setRoot("root2");
- // root2 can unset root root1
- root2WsClient.rootService().unsetRoot("root1");
- // root2 can unset root itself as it's not the last root
- root2WsClient.rootService().unsetRoot("root2");
- }
-
- private static void enableOrganizationSupport() {
- orchestrator.getServer().post("api/organizations/enable_support", Collections.emptyMap());
- }
-
- private static void verifyHttpError(Runnable runnable, int expectedErrorCode) {
- try {
- runnable.run();
- fail("Ws Call should have failed with http code " + expectedErrorCode);
- } catch (HttpException e) {
- assertThat(e.code()).isEqualTo(expectedErrorCode);
- }
- }
-}
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2017 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+package it.organization;
+
+import com.sonar.orchestrator.Orchestrator;
+import it.Category6Suite;
+import java.sql.SQLException;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.ClassRule;
+import org.junit.Test;
+import org.sonarqube.ws.WsRoot;
+import org.sonarqube.ws.client.HttpException;
+import org.sonarqube.ws.client.WsClient;
+import org.sonarqube.ws.client.user.SearchRequest;
+import org.sonarqube.ws.client.user.UsersService;
+import util.user.UserRule;
+
+import static it.Category6Suite.enableOrganizationsSupport;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+import static util.ItUtils.newAdminWsClient;
+import static util.ItUtils.newUserWsClient;
+
+public class RootUserOnOrganizationTest {
+
+ @ClassRule
+ public static Orchestrator orchestrator = Category6Suite.ORCHESTRATOR;
+
+ private static UserRule userRule;
+
+ @Before
+ public void start() {
+ userRule = UserRule.from(orchestrator);
+ }
+
+ @After
+ public void tearDown() throws Exception {
+ UsersService service = newAdminWsClient(orchestrator).users();
+ service.search(SearchRequest.builder().build()).getUsersList()
+ .stream()
+ .filter(u -> !u.getLogin().equals("admin"))
+ .forEach(u -> {
+ userRule.deactivateUsers(u.getLogin());
+ });
+ }
+
+ @BeforeClass
+ public static void enableOrganizations() throws Exception {
+ enableOrganizationsSupport();
+ }
+
+ @Test
+ public void system_administrator_is_flagged_as_root_when_he_enables_organization_support() {
+ assertThat(newAdminWsClient(orchestrator).rootService().search().getRootsList())
+ .extracting(WsRoot.Root::getLogin)
+ .containsOnly(UserRule.ADMIN_LOGIN);
+ }
+
+ @Test
+ public void a_root_can_flag_other_user_as_root() {
+ userRule.createUser("bar", "foo");
+ userRule.setRoot("bar");
+
+ assertThat(newAdminWsClient(orchestrator).rootService().search().getRootsList())
+ .extracting(WsRoot.Root::getLogin)
+ .containsOnly(UserRule.ADMIN_LOGIN, "bar");
+ }
+
+ @Test
+ public void last_root_can_not_be_unset_root() throws SQLException {
+ verifyHttpError(() -> newAdminWsClient(orchestrator).rootService().unsetRoot(UserRule.ADMIN_LOGIN), 400);
+ }
+
+ @Test
+ public void root_can_be_set_and_unset_via_web_services() {
+ userRule.createUser("root1", "bar");
+ userRule.createUser("root2", "bar");
+ WsClient root1WsClient = newUserWsClient(orchestrator, "root1", "bar");
+ WsClient root2WsClient = newUserWsClient(orchestrator, "root2", "bar");
+
+ // non root can not set or unset root another user not itself
+ verifyHttpError(() -> root1WsClient.rootService().setRoot("root2"), 403);
+ verifyHttpError(() -> root1WsClient.rootService().setRoot("root1"), 403);
+ verifyHttpError(() -> root1WsClient.rootService().unsetRoot("root1"), 403);
+ verifyHttpError(() -> root2WsClient.rootService().unsetRoot("root1"), 403);
+ verifyHttpError(() -> root2WsClient.rootService().unsetRoot("root2"), 403);
+ // admin (the first root) sets root1 as root
+ newAdminWsClient(orchestrator).rootService().setRoot("root1");
+ // root1 can set root root2
+ root1WsClient.rootService().setRoot("root2");
+ // root2 can unset root root1
+ root2WsClient.rootService().unsetRoot("root1");
+ // root2 can unset root itself as it's not the last root
+ root2WsClient.rootService().unsetRoot("root2");
+ }
+
+ private static void verifyHttpError(Runnable runnable, int expectedErrorCode) {
+ try {
+ runnable.run();
+ fail("Ws Call should have failed with http code " + expectedErrorCode);
+ } catch (HttpException e) {
+ assertThat(e.code()).isEqualTo(expectedErrorCode);
+ }
+ }
+}
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2017 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+package it.organization;
+
+import com.sonar.orchestrator.Orchestrator;
+import it.Category4Suite;
+import org.junit.ClassRule;
+import org.junit.Test;
+import org.sonarqube.ws.client.HttpException;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+import static util.ItUtils.newAdminWsClient;
+import static util.ItUtils.newWsClient;
+
+public class RootUserTest {
+
+ @ClassRule
+ public static Orchestrator orchestrator = Category4Suite.ORCHESTRATOR;
+
+ @Test
+ public void nobody_is_root_by_default() {
+ // anonymous
+ verifyHttpError(() -> newWsClient(orchestrator).rootService().search(), 403);
+
+ // admin
+ verifyHttpError(() -> newAdminWsClient(orchestrator).rootService().search(), 403);
+ }
+
+ private static void verifyHttpError(Runnable runnable, int expectedErrorCode) {
+ try {
+ runnable.run();
+ fail("Ws Call should have failed with http code " + expectedErrorCode);
+ } catch (HttpException e) {
+ assertThat(e.code()).isEqualTo(expectedErrorCode);
+ }
+ }
+}
import static com.codeborne.selenide.Selenide.$;
import static it.Category6Suite.enableOrganizationsSupport;
-import static util.ItUtils.deleteOrganizationsIfExists;
+import static util.ItUtils.deleteOrganizations;
import static util.ItUtils.newAdminWsClient;
import static util.ItUtils.projectDir;
import static util.selenium.Selenese.runSelenese;
@AfterClass
public static void tearDown() throws Exception {
- deleteOrganizationsIfExists(orchestrator, ORGANIZATION);
+ deleteOrganizations(orchestrator);
}
@Before
import static it.Category6Suite.enableOrganizationsSupport;
import static org.assertj.core.api.Assertions.assertThat;
-import static util.ItUtils.deleteOrganizationsIfExists;
+import static util.ItUtils.deleteOrganizations;
import static util.ItUtils.newAdminWsClient;
import static util.ItUtils.newWsClient;
@AfterClass
public static void tearDown() throws Exception {
- deleteOrganizationsIfExists(orchestrator, ORGANIZATION_FOO);
- deleteOrganizationsIfExists(orchestrator, ORGANIZATION_BAR);
+ deleteOrganizations(orchestrator);
}
private static void createOrganization(String organization) {
return "key-" + randomAlphabetic(100);
}
- public static void deleteOrganizationsIfExists(Orchestrator orchestrator, String... organizationKeys) {
- OrganizationService adminOrganizationService = newAdminWsClient(orchestrator).organizations();
- adminOrganizationService.search(SearchWsRequest.builder().setOrganizations(organizationKeys).build()).getOrganizationsList()
- .forEach(organization -> adminOrganizationService.delete(organization.getKey()));
+ public static void deleteOrganizations(Orchestrator orchestrator) {
+ OrganizationService service = newAdminWsClient(orchestrator).organizations();
+ service.search(SearchWsRequest.builder().build()).getOrganizationsList()
+ .stream()
+ .filter(o -> !o.getGuarded())
+ .forEach(organization -> service.delete(organization.getKey()));
}
public static class ComponentNavigation {
return getMapper(dbSession).selectByPermission(userId, permission);
}
- public List<OrganizationDto> selectWithoutQualityProfile(DbSession dbSession, String profileLanguage, String profileName) {
- return getMapper(dbSession).selectWithoutQualityProfile(profileLanguage, profileName);
+ public List<String> selectAllUuids(DbSession dbSession) {
+ return getMapper(dbSession).selectAllUuids();
}
/**
List<OrganizationDto> selectByPermission(@Param("userId") Integer userId, @Param("permission") String permission);
- List<OrganizationDto> selectWithoutQualityProfile(@Param("profileLanguage") String profileLanguage,
- @Param("profileName") String profileName);
+ List<String> selectAllUuids();
DefaultTemplates selectDefaultTemplatesByUuid(@Param("uuid") String uuid);
*/
package org.sonar.db.qualityprofile;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.util.Collection;
import java.util.List;
import java.util.Map;
-import javax.annotation.CheckForNull;
+import java.util.Optional;
import org.sonar.api.rule.RuleStatus;
import org.sonar.db.Dao;
import org.sonar.db.DatabaseUtils;
import org.sonar.db.DbSession;
import org.sonar.db.KeyLongValue;
-import org.sonar.db.RowNotFoundException;
import org.sonar.db.organization.OrganizationDto;
+import org.sonar.db.rule.RuleParamDto;
import static org.sonar.db.DatabaseUtils.executeLargeInputs;
private static final String QUALITY_PROFILE_IS_NOT_PERSISTED = "Quality profile is not persisted (missing id)";
private static final String RULE_IS_NOT_PERSISTED = "Rule is not persisted";
private static final String RULE_PARAM_IS_NOT_PERSISTED = "Rule param is not persisted";
- private static final String ACTIVE_RULE_KEY_CANNOT_BE_NULL = "ActiveRuleKey cannot be null";
private static final String ACTIVE_RULE_IS_NOT_PERSISTED = "ActiveRule is not persisted";
private static final String ACTIVE_RULE_IS_ALREADY_PERSISTED = "ActiveRule is already persisted";
private static final String ACTIVE_RULE_PARAM_IS_NOT_PERSISTED = "ActiveRuleParam is not persisted";
private static final String ACTIVE_RULE_PARAM_IS_ALREADY_PERSISTED = "ActiveRuleParam is already persisted";
- private static final String PARAMETER_NAME_CANNOT_BE_NULL = "ParameterName cannot be null";
- public Optional<ActiveRuleDto> selectByKey(DbSession session, ActiveRuleKey key) {
- return Optional.fromNullable(mapper(session).selectByKey(key.qProfile(), key.ruleKey().repository(), key.ruleKey().rule()));
+ public Optional<ActiveRuleDto> selectByKey(DbSession dbSession, ActiveRuleKey key) {
+ return Optional.ofNullable(mapper(dbSession).selectByKey(key.getRuleProfileUuid(), key.getRuleKey().repository(), key.getRuleKey().rule()));
}
- public ActiveRuleDto selectOrFailByKey(DbSession session, ActiveRuleKey key) {
- Optional<ActiveRuleDto> activeRule = selectByKey(session, key);
- if (activeRule.isPresent()) {
- return activeRule.get();
- }
- throw new RowNotFoundException(String.format("Active rule with key '%s' does not exist", key));
- }
-
- public List<ActiveRuleDto> selectByRuleId(DbSession dbSession, OrganizationDto organization, int ruleId) {
+ public List<OrgActiveRuleDto> selectByRuleId(DbSession dbSession, OrganizationDto organization, int ruleId) {
return mapper(dbSession).selectByRuleId(organization.getUuid(), ruleId);
}
return mapper(dbSession).selectByRuleIdOfAllOrganizations(ruleId);
}
- public List<ActiveRuleDto> selectByRuleIds(DbSession dbSession, String organizationUuid, List<Integer> ids) {
- return executeLargeInputs(ids, chunk -> mapper(dbSession).selectByRuleIds(organizationUuid, chunk));
+ public List<OrgActiveRuleDto> selectByRuleIds(DbSession dbSession, OrganizationDto organization, List<Integer> ids) {
+ return executeLargeInputs(ids, chunk -> mapper(dbSession).selectByRuleIds(organization.getUuid(), chunk));
}
/**
* Active rule on removed rule are NOT returned
*/
- public List<ActiveRuleDto> selectByProfileKey(DbSession session, String profileKey) {
- return mapper(session).selectByProfileKey(profileKey);
+ public List<OrgActiveRuleDto> selectByProfileUuid(DbSession dbSession, String uuid) {
+ return mapper(dbSession).selectByProfileUuid(uuid);
+ }
+
+ public List<OrgActiveRuleDto> selectByProfile(DbSession dbSession, QProfileDto profile) {
+ return selectByProfileUuid(dbSession, profile.getKee());
}
- public ActiveRuleDto insert(DbSession session, ActiveRuleDto item) {
+ public ActiveRuleDto insert(DbSession dbSession, ActiveRuleDto item) {
Preconditions.checkArgument(item.getProfileId() != null, QUALITY_PROFILE_IS_NOT_PERSISTED);
Preconditions.checkArgument(item.getRuleId() != null, RULE_IS_NOT_PERSISTED);
Preconditions.checkArgument(item.getId() == null, ACTIVE_RULE_IS_ALREADY_PERSISTED);
- mapper(session).insert(item);
+ mapper(dbSession).insert(item);
return item;
}
- public ActiveRuleDto update(DbSession session, ActiveRuleDto item) {
+ public ActiveRuleDto update(DbSession dbSession, ActiveRuleDto item) {
Preconditions.checkArgument(item.getProfileId() != null, QUALITY_PROFILE_IS_NOT_PERSISTED);
Preconditions.checkArgument(item.getRuleId() != null, ActiveRuleDao.RULE_IS_NOT_PERSISTED);
Preconditions.checkArgument(item.getId() != null, ACTIVE_RULE_IS_NOT_PERSISTED);
- mapper(session).update(item);
+ mapper(dbSession).update(item);
return item;
}
- public void delete(DbSession session, ActiveRuleKey key) {
- Optional<ActiveRuleDto> activeRule = selectByKey(session, key);
+ public Optional<ActiveRuleDto> delete(DbSession dbSession, ActiveRuleKey key) {
+ Optional<ActiveRuleDto> activeRule = selectByKey(dbSession, key);
if (activeRule.isPresent()) {
- mapper(session).deleteParameters(activeRule.get().getId());
- mapper(session).delete(activeRule.get().getId());
+ mapper(dbSession).deleteParameters(activeRule.get().getId());
+ mapper(dbSession).delete(activeRule.get().getId());
}
+ return activeRule;
}
- public void deleteByProfileKeys(DbSession dbSession, Collection<String> profileKeys) {
+ public void deleteByRuleProfileUuids(DbSession dbSession, Collection<String> rulesProfileUuids) {
ActiveRuleMapper mapper = mapper(dbSession);
- DatabaseUtils.executeLargeUpdates(profileKeys, mapper::deleteByProfileKeys);
+ DatabaseUtils.executeLargeUpdates(rulesProfileUuids, mapper::deleteByRuleProfileUuids);
}
- public void deleteParametersByProfileKeys(DbSession dbSession, Collection<String> profileKeys) {
+ public void deleteParametersByRuleProfileUuids(DbSession dbSession, Collection<String> rulesProfileUuids) {
ActiveRuleMapper mapper = mapper(dbSession);
- DatabaseUtils.executeLargeUpdates(profileKeys, mapper::deleteParametersByProfileKeys);
+ DatabaseUtils.executeLargeUpdates(rulesProfileUuids, mapper::deleteParametersByRuleProfileUuids);
}
/**
return executeLargeInputs(activeRuleIds, mapper(dbSession)::selectParamsByActiveRuleIds);
}
- @CheckForNull
- public ActiveRuleParamDto selectParamByKeyAndName(ActiveRuleKey key, String name, DbSession session) {
- Preconditions.checkNotNull(key, ACTIVE_RULE_KEY_CANNOT_BE_NULL);
- Preconditions.checkNotNull(name, PARAMETER_NAME_CANNOT_BE_NULL);
- Optional<ActiveRuleDto> activeRule = selectByKey(session, key);
- if (activeRule.isPresent()) {
- return mapper(session).selectParamByActiveRuleAndKey(activeRule.get().getId(), name);
- }
- return null;
- }
-
- /**
- * @deprecated currently used only by tests
- */
- @Deprecated
- public List<ActiveRuleParamDto> selectAllParams(DbSession dbSession) {
- return mapper(dbSession).selectAllParams();
- }
-
- public ActiveRuleParamDto insertParam(DbSession session, ActiveRuleDto activeRule, ActiveRuleParamDto activeRuleParam) {
+ public ActiveRuleParamDto insertParam(DbSession dbSession, ActiveRuleDto activeRule, ActiveRuleParamDto activeRuleParam) {
Preconditions.checkArgument(activeRule.getId() != null, ACTIVE_RULE_IS_NOT_PERSISTED);
Preconditions.checkArgument(activeRuleParam.getId() == null, ACTIVE_RULE_PARAM_IS_ALREADY_PERSISTED);
Preconditions.checkNotNull(activeRuleParam.getRulesParameterId(), RULE_PARAM_IS_NOT_PERSISTED);
activeRuleParam.setActiveRuleId(activeRule.getId());
- mapper(session).insertParameter(activeRuleParam);
+ mapper(dbSession).insertParameter(activeRuleParam);
return activeRuleParam;
}
- public void updateParam(DbSession session, ActiveRuleDto activeRule, ActiveRuleParamDto activeRuleParam) {
- Preconditions.checkNotNull(activeRule.getId(), ACTIVE_RULE_IS_NOT_PERSISTED);
+ public void updateParam(DbSession dbSession, ActiveRuleParamDto activeRuleParam) {
Preconditions.checkNotNull(activeRuleParam.getId(), ACTIVE_RULE_PARAM_IS_NOT_PERSISTED);
- mapper(session).updateParameter(activeRuleParam);
+ mapper(dbSession).updateParameter(activeRuleParam);
}
- public void deleteParam(DbSession session, ActiveRuleDto activeRule, ActiveRuleParamDto activeRuleParam) {
- Preconditions.checkNotNull(activeRule.getId(), ACTIVE_RULE_IS_NOT_PERSISTED);
+ public void deleteParam(DbSession dbSession, ActiveRuleParamDto activeRuleParam) {
Preconditions.checkNotNull(activeRuleParam.getId(), ACTIVE_RULE_PARAM_IS_NOT_PERSISTED);
- deleteParamById(session, activeRuleParam.getId());
+ deleteParamById(dbSession, activeRuleParam.getId());
}
- public void deleteParamById(DbSession session, int id) {
- mapper(session).deleteParameter(id);
- }
-
- public void deleteParamByKeyAndName(DbSession session, ActiveRuleKey key, String param) {
- // TODO SQL rewrite to delete by key
- Optional<ActiveRuleDto> activeRule = selectByKey(session, key);
- if (activeRule.isPresent()) {
- ActiveRuleParamDto activeRuleParam = mapper(session).selectParamByActiveRuleAndKey(activeRule.get().getId(), param);
- if (activeRuleParam != null) {
- mapper(session).deleteParameter(activeRuleParam.getId());
- }
- }
+ public void deleteParamById(DbSession dbSession, int id) {
+ mapper(dbSession).deleteParameter(id);
}
- public void deleteParamsByRuleParamOfAllOrganizations(DbSession dbSession, int ruleId, String paramKey) {
- List<ActiveRuleDto> activeRules = selectByRuleIdOfAllOrganizations(dbSession, ruleId);
+ public void deleteParamsByRuleParamOfAllOrganizations(DbSession dbSession, RuleParamDto param) {
+ List<ActiveRuleDto> activeRules = selectByRuleIdOfAllOrganizations(dbSession, param.getRuleId());
for (ActiveRuleDto activeRule : activeRules) {
for (ActiveRuleParamDto activeParam : selectParamsByActiveRuleId(dbSession, activeRule.getId())) {
- if (activeParam.getKey().equals(paramKey)) {
- deleteParam(dbSession, activeRule, activeParam);
+ if (activeParam.getKey().equals(param.getName())) {
+ deleteParam(dbSession, activeParam);
}
}
}
/**
* Active rule on removed rule are NOT taken into account
*/
- public Map<String, Long> countActiveRulesByProfileKey(DbSession dbSession, OrganizationDto organization) {
+ public Map<String, Long> countActiveRulesByProfileUuid(DbSession dbSession, OrganizationDto organization) {
return KeyLongValue.toMap(
- mapper(dbSession).countActiveRulesByProfileKey(organization.getUuid()));
+ mapper(dbSession).countActiveRulesByProfileUuid(organization.getUuid()));
}
- public Map<String, Long> countActiveRulesForRuleStatusByProfileKey(DbSession dbSession, OrganizationDto organization, RuleStatus ruleStatus) {
+ public Map<String, Long> countActiveRulesForRuleStatusByProfileUuid(DbSession dbSession, OrganizationDto organization, RuleStatus ruleStatus) {
return KeyLongValue.toMap(
- mapper(dbSession).countActiveRulesForRuleStatusByProfileKey(organization.getUuid(), ruleStatus));
+ mapper(dbSession).countActiveRulesForRuleStatusByProfileUuid(organization.getUuid(), ruleStatus));
}
/**
* Active rule on removed rule are NOT taken into account
*/
- public Map<String, Long> countActiveRulesForInheritanceByProfileKey(DbSession dbSession, OrganizationDto organization, String inheritance) {
+ public Map<String, Long> countActiveRulesForInheritanceByProfileUuid(DbSession dbSession, OrganizationDto organization, String inheritance) {
return KeyLongValue.toMap(
- mapper(dbSession).countActiveRulesForInheritanceByProfileKey(organization.getUuid(), inheritance));
+ mapper(dbSession).countActiveRulesForInheritanceByProfileUuid(organization.getUuid(), inheritance));
}
- private static ActiveRuleMapper mapper(DbSession session) {
- return session.getMapper(ActiveRuleMapper.class);
+ private static ActiveRuleMapper mapper(DbSession dbSession) {
+ return dbSession.getMapper(ActiveRuleMapper.class);
}
}
// These fields do not exists in db, it's only retrieve by joins
private String repository;
private String ruleField;
- private String profileKey;
+ private String ruleProfileUuid;
public ActiveRuleDto setKey(ActiveRuleKey key) {
- this.repository = key.ruleKey().repository();
- this.ruleField = key.ruleKey().rule();
- this.profileKey = key.qProfile();
+ this.repository = key.getRuleKey().repository();
+ this.ruleField = key.getRuleKey().rule();
+ this.ruleProfileUuid = key.getRuleProfileUuid();
return this;
}
public ActiveRuleKey getKey() {
- return ActiveRuleKey.of(profileKey, RuleKey.of(repository, ruleField));
+ return new ActiveRuleKey(ruleProfileUuid, RuleKey.of(repository, ruleField));
+ }
+
+ public RuleKey getRuleKey() {
+ return RuleKey.of(repository, ruleField);
}
public Integer getId() {
return this;
}
- public static ActiveRuleDto createFor(QProfileDto profileDto, RuleDefinitionDto ruleDto) {
- requireNonNull(profileDto.getId(), "Profile is not persisted");
+ public static ActiveRuleDto createFor(QProfileDto profile, RuleDefinitionDto ruleDto) {
+ requireNonNull(profile.getId(), "Profile is not persisted");
requireNonNull(ruleDto.getId(), "Rule is not persisted");
ActiveRuleDto dto = new ActiveRuleDto();
- dto.setProfileId(profileDto.getId());
+ dto.setProfileId(profile.getId());
dto.setRuleId(ruleDto.getId());
- dto.setKey(ActiveRuleKey.of(profileDto.getKee(), ruleDto.getKey()));
+ dto.setKey(ActiveRuleKey.of(profile, ruleDto.getKey()));
return dto;
}
*/
public class ActiveRuleKey implements Serializable, Comparable<ActiveRuleKey> {
- private final String qualityProfileKey;
+ private final String ruleProfileUuid;
private final RuleKey ruleKey;
- protected ActiveRuleKey(String qualityProfileKey, RuleKey ruleKey) {
- this.qualityProfileKey = qualityProfileKey;
+ protected ActiveRuleKey(String ruleProfileUuid, RuleKey ruleKey) {
+ this.ruleProfileUuid = ruleProfileUuid;
this.ruleKey = ruleKey;
}
/**
* Create a key. Parameters are NOT null.
*/
- public static ActiveRuleKey of(String qualityProfileKey, RuleKey ruleKey) {
- Preconditions.checkNotNull(qualityProfileKey, "QProfile is missing");
- Preconditions.checkNotNull(ruleKey, "RuleKey is missing");
- return new ActiveRuleKey(qualityProfileKey, ruleKey);
+ public static ActiveRuleKey of(QProfileDto profile, RuleKey ruleKey) {
+ return new ActiveRuleKey(profile.getRulesProfileUuid(), ruleKey);
+ }
+
+ public static ActiveRuleKey of(RulesProfileDto rulesProfile, RuleKey ruleKey) {
+ return new ActiveRuleKey(rulesProfile.getKee(), ruleKey);
}
/**
public static ActiveRuleKey parse(String s) {
Preconditions.checkArgument(s.split(":").length >= 3, "Bad format of activeRule key: " + s);
int semiColonPos = s.indexOf(':');
- String key = s.substring(0, semiColonPos);
+ String ruleProfileUuid = s.substring(0, semiColonPos);
String ruleKey = s.substring(semiColonPos + 1);
- return ActiveRuleKey.of(key, RuleKey.parse(ruleKey));
+ return new ActiveRuleKey(ruleProfileUuid, RuleKey.parse(ruleKey));
}
/**
* Never null
*/
- public RuleKey ruleKey() {
+ public RuleKey getRuleKey() {
return ruleKey;
}
/**
* Never null
*/
- public String qProfile() {
- return qualityProfileKey;
+ public String getRuleProfileUuid() {
+ return ruleProfileUuid;
}
@Override
return false;
}
ActiveRuleKey activeRuleKey = (ActiveRuleKey) o;
- if (!qualityProfileKey.equals(activeRuleKey.qualityProfileKey)) {
+ if (!ruleProfileUuid.equals(activeRuleKey.ruleProfileUuid)) {
return false;
}
return ruleKey.equals(activeRuleKey.ruleKey);
@Override
public int hashCode() {
- int result = qualityProfileKey.hashCode();
+ int result = ruleProfileUuid.hashCode();
result = 31 * result + ruleKey.hashCode();
return result;
}
*/
@Override
public String toString() {
- return String.format("%s:%s", qualityProfileKey, ruleKey.toString());
+ return String.format("%s:%s", ruleProfileUuid, ruleKey.toString());
}
@Override
public int compareTo(ActiveRuleKey o) {
- int compareQualityProfileKey = this.qualityProfileKey.compareTo(o.qualityProfileKey);
+ int compareQualityProfileKey = this.ruleProfileUuid.compareTo(o.ruleProfileUuid);
if (compareQualityProfileKey == 0) {
return this.ruleKey.compareTo(o.ruleKey);
}
void delete(int activeRuleId);
- void deleteByProfileKeys(@Param("profileKeys") Collection<String> profileKeys);
+ void deleteByRuleProfileUuids(@Param("rulesProfileUuids") Collection<String> rulesProfileUuids);
- ActiveRuleDto selectByKey(@Param("profileKey") String profileKey, @Param("repository") String repository, @Param("rule") String rule);
+ @CheckForNull
+ ActiveRuleDto selectByKey(@Param("ruleProfileUuid") String ruleProfileUuid, @Param("repository") String repository, @Param("rule") String rule);
List<ActiveRuleDto> selectByKeys(@Param("keys") List<ActiveRuleKey> keys);
- List<ActiveRuleDto> selectByRuleId(@Param("organizationUuid") String organizationUuid, @Param("ruleId") int ruleId);
+ List<OrgActiveRuleDto> selectByRuleId(@Param("organizationUuid") String organizationUuid, @Param("ruleId") int ruleId);
List<ActiveRuleDto> selectByRuleIdOfAllOrganizations(int ruleId);
- List<ActiveRuleDto> selectByRuleIds(@Param("organizationUuid") String organizationUuid, @Param("ruleIds") List<Integer> partitionOfRuleIds);
+ List<OrgActiveRuleDto> selectByRuleIds(@Param("organizationUuid") String organizationUuid, @Param("ruleIds") List<Integer> partitionOfRuleIds);
- List<ActiveRuleDto> selectByProfileKey(String key);
+ List<OrgActiveRuleDto> selectByProfileUuid(String uuid);
void insertParameter(ActiveRuleParamDto dto);
void deleteParameters(int activeRuleId);
- void deleteParametersByProfileKeys(@Param("profileKeys") Collection<String> profileKeys);
+ void deleteParametersByRuleProfileUuids(@Param("rulesProfileUuids") Collection<String> rulesProfileUuids);
void deleteParameter(int activeRuleParamId);
- @CheckForNull
- ActiveRuleParamDto selectParamByActiveRuleAndKey(@Param("activeRuleId") int activeRuleId, @Param("key") String key);
-
List<ActiveRuleParamDto> selectParamsByActiveRuleId(int activeRuleId);
List<ActiveRuleParamDto> selectParamsByActiveRuleIds(@Param("ids") List<Integer> ids);
- List<ActiveRuleParamDto> selectAllParams();
-
- List<KeyLongValue> countActiveRulesByProfileKey(@Param("organizationUuid") String organizationUuid);
+ List<KeyLongValue> countActiveRulesByProfileUuid(@Param("organizationUuid") String organizationUuid);
- List<KeyLongValue> countActiveRulesForRuleStatusByProfileKey(@Param("organizationUuid") String organizationUuid, @Param("ruleStatus") RuleStatus ruleStatus);
+ List<KeyLongValue> countActiveRulesForRuleStatusByProfileUuid(@Param("organizationUuid") String organizationUuid, @Param("ruleStatus") RuleStatus ruleStatus);
- List<KeyLongValue> countActiveRulesForInheritanceByProfileKey(@Param("organizationUuid") String organizationUuid, @Param("inheritance") String inheritance);
+ List<KeyLongValue> countActiveRulesForInheritanceByProfileUuid(@Param("organizationUuid") String organizationUuid, @Param("inheritance") String inheritance);
}
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2017 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+package org.sonar.db.qualityprofile;
+
+public class OrgActiveRuleDto extends ActiveRuleDto {
+
+ private String organizationUuid;
+ private String profileUuid;
+
+ public String getOrganizationUuid() {
+ return organizationUuid;
+ }
+
+ public OrgActiveRuleDto setOrganizationUuid(String s) {
+ this.organizationUuid = s;
+ return this;
+ }
+
+ public String getProfileUuid() {
+ return profileUuid;
+ }
+
+ public OrgActiveRuleDto setProfileUuid(String s) {
+ this.profileUuid = s;
+ return this;
+ }
+}
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2017 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+package org.sonar.db.qualityprofile;
+
+import javax.annotation.CheckForNull;
+import javax.annotation.Nullable;
+
+/**
+ * Represents the table "org_qprofiles"
+ */
+public class OrgQProfileDto {
+
+ private String uuid;
+ private String organizationUuid;
+ private String rulesProfileUuid;
+ private String parentUuid;
+
+ public String getOrganizationUuid() {
+ return organizationUuid;
+ }
+
+ public OrgQProfileDto setOrganizationUuid(String organizationUuid) {
+ this.organizationUuid = organizationUuid;
+ return this;
+ }
+
+ public String getUuid() {
+ return uuid;
+ }
+
+ public OrgQProfileDto setUuid(String s) {
+ this.uuid = s;
+ return this;
+ }
+
+ public String getRulesProfileUuid() {
+ return rulesProfileUuid;
+ }
+
+ public OrgQProfileDto setRulesProfileUuid(String s) {
+ this.rulesProfileUuid = s;
+ return this;
+ }
+
+ @CheckForNull
+ public String getParentUuid() {
+ return parentUuid;
+ }
+
+ public OrgQProfileDto setParentUuid(@Nullable String s) {
+ this.parentUuid = s;
+ return this;
+ }
+
+ public static OrgQProfileDto from(QProfileDto qProfileDto) {
+ return new OrgQProfileDto()
+ .setUuid(qProfileDto.getKee())
+ .setOrganizationUuid(qProfileDto.getOrganizationUuid())
+ .setRulesProfileUuid(qProfileDto.getRulesProfileUuid())
+ .setParentUuid(qProfileDto.getParentKee());
+ }
+}
public void insert(DbSession dbSession, QProfileChangeDto dto) {
checkState(dto.getCreatedAt() == 0L, "Date of QProfileChangeDto must be set by DAO only. Got %s.", dto.getCreatedAt());
- dto.setKey(uuidFactory.create());
+ dto.setUuid(uuidFactory.create());
dto.setCreatedAt(system2.now());
mapper(dbSession).insert(dto);
}
return mapper(dbSession).selectByQuery(query);
}
- public int countForProfileUuid(DbSession dbSession, String profileUuid) {
- return mapper(dbSession).countForProfileUuid(profileUuid);
+ public int countForQProfileUuid(DbSession dbSession, String profileUuid) {
+ return mapper(dbSession).countForQProfileUuid(profileUuid);
}
- public void deleteByProfileKeys(DbSession dbSession, Collection<String> profileUuids) {
+ public void deleteByRulesProfileUuids(DbSession dbSession, Collection<String> ruleProfileUuids) {
QProfileChangeMapper mapper = mapper(dbSession);
- DatabaseUtils.executeLargeUpdates(profileUuids, mapper::deleteByProfileUuids);
+ DatabaseUtils.executeLargeUpdates(ruleProfileUuids, mapper::deleteByRuleProfileUuids);
}
private static QProfileChangeMapper mapper(DbSession dbSession) {
public class QProfileChangeDto {
- private String key;
- private String profileKey;
- // can't be named "type" because it's a reserved word in Oracle
- // (used by Mybatis to map DB column with DTO field)
+ private String uuid;
+ private String rulesProfileUuid;
private String changeType;
private String login;
private String data;
private long createdAt;
- public String getKey() {
- return key;
+ public String getUuid() {
+ return uuid;
}
- public QProfileChangeDto setKey(String s) {
- this.key = s;
+ public QProfileChangeDto setUuid(String s) {
+ this.uuid = s;
return this;
}
- public String getProfileKey() {
- return profileKey;
+ public String getRulesProfileUuid() {
+ return rulesProfileUuid;
}
- public QProfileChangeDto setProfileKey(String s) {
- this.profileKey = s;
+ public QProfileChangeDto setRulesProfileUuid(String s) {
+ this.rulesProfileUuid = s;
return this;
}
List<QProfileChangeDto> selectByQuery(@Param("query") QProfileChangeQuery query);
- int countForProfileUuid(@Param("profileUuid") String profileUuid);
+ int countForQProfileUuid(@Param("qProfileUuid") String qProfileUuid);
- void deleteByProfileUuids(@Param("profileUuids") Collection<String> profileUuids);
+ void deleteByRuleProfileUuids(@Param("ruleProfileUuids") Collection<String> uuids);
}
import static java.util.Objects.requireNonNull;
-public class QProfileChangeQuery {
+public final class QProfileChangeQuery {
private final String profileUuid;
private Long fromIncluded;
private Long lastUsed;
private Long userUpdatedAt;
private boolean isBuiltIn;
+ private String rulesProfileUuid;
public String getOrganizationUuid() {
return organizationUuid;
}
- public QProfileDto setOrganizationUuid(String organizationUuid) {
- this.organizationUuid = organizationUuid;
+ public QProfileDto setOrganizationUuid(String s) {
+ this.organizationUuid = s;
return this;
}
- public QProfileDto setKey(String s) {
- return setKee(s);
- }
-
public String getKee() {
return kee;
}
return this;
}
+ public String getRulesProfileUuid() {
+ return rulesProfileUuid;
+ }
+
+ public QProfileDto setRulesProfileUuid(String s) {
+ this.rulesProfileUuid = s;
+ return this;
+ }
+
public Integer getId() {
return id;
}
return this;
}
- public static QProfileDto createFor(String key) {
- return new QProfileDto().setKee(key);
+ public static QProfileDto from(OrgQProfileDto org, RulesProfileDto rules) {
+ return new QProfileDto()
+ .setIsBuiltIn(rules.isBuiltIn())
+ .setKee(org.getUuid())
+ .setParentKee(org.getParentUuid())
+ .setOrganizationUuid(org.getOrganizationUuid())
+ .setId(rules.getId())
+ .setRulesProfileUuid(rules.getKee())
+ .setLanguage(rules.getLanguage())
+ .setName(rules.getName())
+ .setRulesUpdatedAt(rules.getRulesUpdatedAt())
+ .setLastUsed(rules.getLastUsed())
+ .setUserUpdatedAt(rules.getUserUpdatedAt());
}
}
*/
package org.sonar.db.qualityprofile;
-import com.google.common.base.Preconditions;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import org.sonar.db.component.ComponentDto;
import org.sonar.db.organization.OrganizationDto;
+import static com.google.common.base.Preconditions.checkArgument;
import static org.sonar.db.DatabaseUtils.executeLargeInputs;
import static org.sonar.db.DatabaseUtils.executeLargeUpdates;
}
@CheckForNull
- public QProfileDto selectByUuid(DbSession session, String uuid) {
- return mapper(session).selectByUuid(uuid);
+ public QProfileDto selectByUuid(DbSession dbSession, String uuid) {
+ return mapper(dbSession).selectByUuid(uuid);
}
- public QProfileDto selectOrFailByUuid(DbSession session, String uuid) {
- QProfileDto dto = selectByUuid(session, uuid);
+ public QProfileDto selectOrFailByUuid(DbSession dbSession, String uuid) {
+ QProfileDto dto = selectByUuid(dbSession, uuid);
if (dto == null) {
throw new RowNotFoundException("Quality profile not found: " + uuid);
}
return dto;
}
- public List<QProfileDto> selectByUuids(DbSession session, List<String> uuids) {
- return executeLargeInputs(uuids, mapper(session)::selectByUuids);
+ public List<QProfileDto> selectByUuids(DbSession dbSession, List<String> uuids) {
+ return executeLargeInputs(uuids, mapper(dbSession)::selectByUuids);
}
- public List<QProfileDto> selectAll(DbSession session, OrganizationDto organization) {
- return mapper(session).selectAll(organization.getUuid());
+ public List<QProfileDto> selectOrderedByOrganizationUuid(DbSession dbSession, OrganizationDto organization) {
+ return mapper(dbSession).selectOrderedByOrganizationUuid(organization.getUuid());
}
- public void insert(DbSession session, QProfileDto profile, QProfileDto... otherProfiles) {
- QualityProfileMapper mapper = mapper(session);
+ public List<RulesProfileDto> selectBuiltInRulesProfiles(DbSession dbSession) {
+ return mapper(dbSession).selectBuiltInRuleProfiles();
+ }
+
+ public void insert(DbSession dbSession, RulesProfileDto dto) {
+ QualityProfileMapper mapper = mapper(dbSession);
+ mapper.insertRuleProfile(dto, new Date(system.now()));
+ }
+
+ public void insert(DbSession dbSession, OrgQProfileDto dto) {
+ QualityProfileMapper mapper = mapper(dbSession);
+ mapper.insertOrgQProfile(dto, system.now());
+ }
+
+ public void insert(DbSession dbSession, QProfileDto profile, QProfileDto... otherProfiles) {
+ QualityProfileMapper mapper = mapper(dbSession);
doInsert(mapper, profile);
for (QProfileDto other : otherProfiles) {
doInsert(mapper, other);
}
private void doInsert(QualityProfileMapper mapper, QProfileDto profile) {
- Preconditions.checkArgument(profile.getId() == null, "Quality profile is already persisted (got id %d)", profile.getId());
+ checkArgument(profile.getId() == null, "Quality profile is already persisted (got id %d)", profile.getId());
long now = system.now();
- mapper.insertRulesProfile(profile, new Date(now));
- mapper.insertOrgQProfile(profile, now);
+ RulesProfileDto rulesProfile = RulesProfileDto.from(profile);
+ mapper.insertRuleProfile(rulesProfile, new Date(now));
+ mapper.insertOrgQProfile(OrgQProfileDto.from(profile), now);
+ profile.setId(rulesProfile.getId());
}
- public void update(DbSession session, QProfileDto profile, QProfileDto... otherProfiles) {
- QualityProfileMapper mapper = mapper(session);
+ public void update(DbSession dbSession, QProfileDto profile, QProfileDto... otherProfiles) {
+ QualityProfileMapper mapper = mapper(dbSession);
long now = system.now();
doUpdate(mapper, profile, now);
for (QProfileDto otherProfile : otherProfiles) {
}
private void doUpdate(QualityProfileMapper mapper, QProfileDto profile, long now) {
- mapper.updateRulesProfile(profile, new Date(now));
+ mapper.updateRuleProfile(profile, new Date(now));
mapper.updateOrgQProfile(profile, now);
}
- public List<QProfileDto> selectDefaultProfiles(DbSession session, OrganizationDto organization, Collection<String> languages) {
- return mapper(session).selectDefaultProfiles(organization.getUuid(), languages);
+ public List<QProfileDto> selectDefaultProfiles(DbSession dbSession, OrganizationDto organization, Collection<String> languages) {
+ return mapper(dbSession).selectDefaultProfiles(organization.getUuid(), languages);
}
@CheckForNull
- public QProfileDto selectDefaultProfile(DbSession session, OrganizationDto organization, String language) {
- return mapper(session).selectDefaultProfile(organization.getUuid(), language);
+ public QProfileDto selectDefaultProfile(DbSession dbSession, OrganizationDto organization, String language) {
+ return mapper(dbSession).selectDefaultProfile(organization.getUuid(), language);
}
@CheckForNull
- public QProfileDto selectAssociatedToProjectAndLanguage(DbSession session, ComponentDto project, String language) {
- return mapper(session).selectAssociatedToProjectUuidAndLanguage(project.getOrganizationUuid(), project.projectUuid(), language);
+ public QProfileDto selectAssociatedToProjectAndLanguage(DbSession dbSession, ComponentDto project, String language) {
+ return mapper(dbSession).selectAssociatedToProjectUuidAndLanguage(project.getOrganizationUuid(), project.projectUuid(), language);
}
- public List<QProfileDto> selectAssociatedToProjectUuidAndLanguages(DbSession session, ComponentDto project, Collection<String> languages) {
- return mapper(session).selectAssociatedToProjectUuidAndLanguages(project.getOrganizationUuid(), project.uuid(), languages);
+ public List<QProfileDto> selectAssociatedToProjectUuidAndLanguages(DbSession dbSession, ComponentDto project, Collection<String> languages) {
+ return mapper(dbSession).selectAssociatedToProjectUuidAndLanguages(project.getOrganizationUuid(), project.uuid(), languages);
}
public List<QProfileDto> selectByLanguage(DbSession dbSession, OrganizationDto organization, String language) {
return mapper(dbSession).selectByLanguage(organization.getUuid(), language);
}
- public List<QProfileDto> selectChildren(DbSession session, String uuid) {
- return mapper(session).selectChildren(uuid);
+ public List<QProfileDto> selectChildren(DbSession dbSession, QProfileDto profile) {
+ return mapper(dbSession).selectChildren(profile.getKee());
}
/**
* All descendants, in the top-down order.
*/
- public List<QProfileDto> selectDescendants(DbSession session, String uuid) {
+ public List<QProfileDto> selectDescendants(DbSession dbSession, QProfileDto profile) {
List<QProfileDto> descendants = new ArrayList<>();
- for (QProfileDto child : selectChildren(session, uuid)) {
+ for (QProfileDto child : selectChildren(dbSession, profile)) {
descendants.add(child);
- descendants.addAll(selectDescendants(session, child.getKee()));
+ descendants.addAll(selectDescendants(dbSession, child));
}
return descendants;
}
@CheckForNull
- public QProfileDto selectByNameAndLanguage(DbSession session, OrganizationDto organization, String name, String language) {
- return mapper(session).selectByNameAndLanguage(organization.getUuid(), name, language);
+ public QProfileDto selectByNameAndLanguage(DbSession dbSession, OrganizationDto organization, String name, String language) {
+ return mapper(dbSession).selectByNameAndLanguage(organization.getUuid(), name, language);
}
- public List<QProfileDto> selectByNameAndLanguages(DbSession session, OrganizationDto organization, String name, Collection<String> languages) {
- return mapper(session).selectByNameAndLanguages(organization.getUuid(), name, languages);
+ public List<QProfileDto> selectByNameAndLanguages(DbSession dbSession, OrganizationDto organization, String name, Collection<String> languages) {
+ return mapper(dbSession).selectByNameAndLanguages(organization.getUuid(), name, languages);
}
public Map<String, Long> countProjectsByProfileUuid(DbSession dbSession, OrganizationDto organization) {
DatabaseUtils.executeLargeUpdates(profileUuids, mapper::deleteProjectAssociationByProfileUuids);
}
- public List<ProjectQprofileAssociationDto> selectSelectedProjects(DbSession session, OrganizationDto organization, QProfileDto profile, @Nullable String query) {
+ public List<ProjectQprofileAssociationDto> selectSelectedProjects(DbSession dbSession, OrganizationDto organization, QProfileDto profile, @Nullable String query) {
String nameQuery = sqlQueryString(query);
- return mapper(session).selectSelectedProjects(organization.getUuid(), profile.getKee(), nameQuery);
+ return mapper(dbSession).selectSelectedProjects(organization.getUuid(), profile.getKee(), nameQuery);
}
- public List<ProjectQprofileAssociationDto> selectDeselectedProjects(DbSession session, OrganizationDto organization, QProfileDto profile, @Nullable String query) {
+ public List<ProjectQprofileAssociationDto> selectDeselectedProjects(DbSession dbSession, OrganizationDto organization, QProfileDto profile, @Nullable String query) {
String nameQuery = sqlQueryString(query);
- return mapper(session).selectDeselectedProjects(organization.getUuid(), profile.getKee(), nameQuery);
+ return mapper(dbSession).selectDeselectedProjects(organization.getUuid(), profile.getKee(), nameQuery);
}
- public List<ProjectQprofileAssociationDto> selectProjectAssociations(DbSession session, OrganizationDto organization, QProfileDto profile, @Nullable String query) {
+ public List<ProjectQprofileAssociationDto> selectProjectAssociations(DbSession dbSession, OrganizationDto organization, QProfileDto profile, @Nullable String query) {
String nameQuery = sqlQueryString(query);
- return mapper(session).selectProjectAssociations(organization.getUuid(), profile.getKee(), nameQuery);
+ return mapper(dbSession).selectProjectAssociations(organization.getUuid(), profile.getKee(), nameQuery);
}
public Collection<String> selectUuidsOfCustomRulesProfiles(DbSession dbSession, String language, String name) {
- return mapper(dbSession).selectUuidsOfCustomQProfiles(language, name);
+ return mapper(dbSession).selectUuidsOfCustomRuleProfiles(language, name);
}
public void renameRulesProfilesAndCommit(DbSession dbSession, Collection<String> rulesProfileUuids, String newName) {
QualityProfileMapper mapper = mapper(dbSession);
Date now = new Date(system.now());
executeLargeUpdates(rulesProfileUuids, partition -> {
- mapper.renameRulesProfiles(newName, now, partition);
+ mapper.renameRuleProfiles(newName, now, partition);
dbSession.commit();
});
}
- public void deleteByUuids(DbSession dbSession, Collection<String> profileUuids) {
+ public void deleteOrgQProfilesByUuids(DbSession dbSession, Collection<String> profileUuids) {
QualityProfileMapper mapper = mapper(dbSession);
DatabaseUtils.executeLargeUpdates(profileUuids, mapper::deleteOrgQProfilesByUuids);
- DatabaseUtils.executeLargeUpdates(profileUuids, mapper::deleteRulesProfilesByUuids);
+ }
+
+ public void deleteRulesProfilesByUuids(DbSession dbSession, Collection<String> rulesProfileUuids) {
+ QualityProfileMapper mapper = mapper(dbSession);
+ DatabaseUtils.executeLargeUpdates(rulesProfileUuids, mapper::deleteRuleProfilesByUuids);
}
private static String sqlQueryString(@Nullable String query) {
return "%" + query.toUpperCase(Locale.ENGLISH) + "%";
}
- private static QualityProfileMapper mapper(DbSession session) {
- return session.getMapper(QualityProfileMapper.class);
+ private static QualityProfileMapper mapper(DbSession dbSession) {
+ return dbSession.getMapper(QualityProfileMapper.class);
}
}
public interface QualityProfileMapper {
- void insertOrgQProfile(@Param("dto") QProfileDto dto, @Param("now") long now);
+ void insertOrgQProfile(@Param("dto") OrgQProfileDto dto, @Param("now") long now);
- void insertRulesProfile(@Param("dto") QProfileDto dto, @Param("now") Date now);
+ void insertRuleProfile(@Param("dto") RulesProfileDto dto, @Param("now") Date now);
- void updateRulesProfile(@Param("dto") QProfileDto dto, @Param("now") Date now);
+ void updateRuleProfile(@Param("dto") QProfileDto dto, @Param("now") Date now);
void updateOrgQProfile(@Param("dto") QProfileDto dto, @Param("now") long now);
- void deleteRulesProfilesByUuids(@Param("uuids") Collection<String> uuids);
+ void deleteRuleProfilesByUuids(@Param("uuids") Collection<String> uuids);
void deleteOrgQProfilesByUuids(@Param("uuids") Collection<String> uuids);
- List<QProfileDto> selectAll(@Param("organizationUuid") String organizationUuid);
+ List<RulesProfileDto> selectBuiltInRuleProfiles();
+
+ List<QProfileDto> selectOrderedByOrganizationUuid(@Param("organizationUuid") String organizationUuid);
@CheckForNull
QProfileDto selectDefaultProfile(@Param("organizationUuid") String organizationUuid, @Param("language") String language);
@Param("profileUuid") String profileUuid,
@Param("nameQuery") String nameQuery);
- List<String> selectUuidsOfCustomQProfiles(@Param("language") String language, @Param("name") String name);
+ List<String> selectUuidsOfCustomRuleProfiles(@Param("language") String language, @Param("name") String name);
- void renameRulesProfiles(@Param("newName") String newName, @Param("updatedAt") Date updatedAt, @Param("uuids") Collection<String> uuids);
+ void renameRuleProfiles(@Param("newName") String newName, @Param("updatedAt") Date updatedAt, @Param("uuids") Collection<String> uuids);
}
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2017 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+package org.sonar.db.qualityprofile;
+
+import java.util.Date;
+import javax.annotation.CheckForNull;
+import javax.annotation.Nullable;
+import org.sonar.core.util.UtcDateUtils;
+
+/**
+ * Represents the table "rules_profiles"
+ */
+public class RulesProfileDto {
+
+ private Integer id;
+ private String kee;
+ private String name;
+ private String language;
+ private String rulesUpdatedAt;
+ private Long lastUsed;
+ private Long userUpdatedAt;
+ private boolean isBuiltIn;
+
+ public String getKee() {
+ return kee;
+ }
+
+ public RulesProfileDto setKee(String s) {
+ this.kee = s;
+ return this;
+ }
+
+ public Integer getId() {
+ return id;
+ }
+
+ public RulesProfileDto setId(Integer id) {
+ this.id = id;
+ return this;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public RulesProfileDto setName(String name) {
+ this.name = name;
+ return this;
+ }
+
+ public String getLanguage() {
+ return language;
+ }
+
+ public RulesProfileDto setLanguage(String language) {
+ this.language = language;
+ return this;
+ }
+
+ public String getRulesUpdatedAt() {
+ return rulesUpdatedAt;
+ }
+
+ public RulesProfileDto setRulesUpdatedAt(String s) {
+ this.rulesUpdatedAt = s;
+ return this;
+ }
+
+ public RulesProfileDto setRulesUpdatedAtAsDate(Date d) {
+ this.rulesUpdatedAt = UtcDateUtils.formatDateTime(d);
+ return this;
+ }
+
+ @CheckForNull
+ public Long getLastUsed() {
+ return lastUsed;
+ }
+
+ public RulesProfileDto setLastUsed(@Nullable Long lastUsed) {
+ this.lastUsed = lastUsed;
+ return this;
+ }
+
+ @CheckForNull
+ public Long getUserUpdatedAt() {
+ return userUpdatedAt;
+ }
+
+ public RulesProfileDto setUserUpdatedAt(@Nullable Long userUpdatedAt) {
+ this.userUpdatedAt = userUpdatedAt;
+ return this;
+ }
+
+ public boolean isBuiltIn() {
+ return isBuiltIn;
+ }
+
+ public RulesProfileDto setIsBuiltIn(boolean b) {
+ this.isBuiltIn = b;
+ return this;
+ }
+
+ public static RulesProfileDto from(QProfileDto qProfileDto) {
+ return new RulesProfileDto()
+ .setKee(qProfileDto.getRulesProfileUuid())
+ .setLanguage(qProfileDto.getLanguage())
+ .setName(qProfileDto.getName())
+ .setIsBuiltIn(qProfileDto.isBuiltIn())
+ .setId(qProfileDto.getId())
+ .setLastUsed(qProfileDto.getLastUsed())
+ .setRulesUpdatedAt(qProfileDto.getRulesUpdatedAt())
+ .setUserUpdatedAt(qProfileDto.getUserUpdatedAt());
+ }
+}
return executeLargeInputs(ids, mapper(session)::selectDefinitionByIds);
}
+ public List<RuleDto> selectByKeys(DbSession session, OrganizationDto organization, Collection<RuleKey> keys) {
+ return ensureOrganizationIsSet(organization.getUuid(),
+ executeLargeInputs(keys, chunk -> mapper(session).selectByKeys(organization.getUuid(), chunk)));
+ }
+
public List<RuleDto> selectByKeys(DbSession session, String organizationUuid, Collection<RuleKey> keys) {
return ensureOrganizationIsSet(organizationUuid,
executeLargeInputs(keys, chunk -> mapper(session).selectByKeys(organizationUuid, chunk)));
and gu.user_id = #{userId,jdbcType=INTEGER}
</select>
- <select id="selectWithoutQualityProfile" parameterType="map" resultType="Organization">
- select
- <include refid="selectColumns"/>
- from organizations org
- where not exists (
- select 1 from rules_profiles p
- inner join org_qprofiles oqp on oqp.rules_profile_uuid = p.kee
- where oqp.organization_uuid = org.uuid
- and p.language = #{profileLanguage, jdbcType=VARCHAR}
- and p.name = #{profileName, jdbcType=VARCHAR}
- )
+ <select id="selectAllUuids" resultType="String">
+ select uuid from organizations
</select>
+
<select id="selectDefaultGroupIdByUuid" resultType="Integer">
select org.default_group_id
from organizations org
<mapper namespace="org.sonar.db.qualityprofile.ActiveRuleMapper">
- <sql id="activeRuleKeyColumns">
+ <sql id="activeRuleColumns">
a.id,
a.profile_id as "profileId",
a.rule_id as "ruleId",
a.inheritance as "inheritance",
r.plugin_rule_key as "rulefield",
r.plugin_name as "repository",
- qp.kee as "profileKey",
+ rp.kee as "ruleProfileUuid",
a.created_at as "createdAt",
a.updated_at as "updatedAt"
</sql>
+ <sql id="orgActiveRuleColumns">
+ a.id,
+ a.profile_id as "profileId",
+ a.rule_id as "ruleId",
+ a.failure_level as "severity",
+ a.inheritance as "inheritance",
+ r.plugin_rule_key as "rulefield",
+ r.plugin_name as "repository",
+ rp.kee as "ruleProfileUuid",
+ a.created_at as "createdAt",
+ a.updated_at as "updatedAt",
+ oqp.organization_uuid as "organizationUuid",
+ oqp.uuid as "profileUuid"
+ </sql>
+
<sql id="activeRuleKeyJoin">
- inner join rules_profiles qp on qp.id=a.profile_id
- inner join org_qprofiles oqp on oqp.rules_profile_uuid = qp.kee
+ inner join rules_profiles rp on rp.id = a.profile_id
inner join rules r on r.id = a.rule_id
</sql>
<insert id="insert" parameterType="ActiveRule" keyColumn="id" useGeneratedKeys="true" keyProperty="id">
- INSERT INTO active_rules (profile_id, rule_id, failure_level, inheritance, created_at, updated_at)
- VALUES (#{profileId}, #{ruleId}, #{severity}, #{inheritance}, #{createdAt}, #{updatedAt})
+ insert into active_rules (
+ profile_id,
+ rule_id,
+ failure_level,
+ inheritance,
+ created_at,
+ updated_at
+ ) values (
+ #{profileId, jdbcType=BIGINT},
+ #{ruleId, jdbcType=BIGINT},
+ #{severity, jdbcType=INTEGER},
+ #{inheritance, jdbcType=VARCHAR},
+ #{createdAt, jdbcType=BIGINT},
+ #{updatedAt, jdbcType=BIGINT}
+ )
</insert>
<update id="update" parameterType="ActiveRule">
- UPDATE active_rules SET
- failure_level=#{severity},
- inheritance=#{inheritance},
- updated_at=#{updatedAt}
- WHERE id=#{id}
+ update active_rules
+ set
+ failure_level = #{severity, jdbcType=INTEGER},
+ inheritance = #{inheritance, jdbcType=VARCHAR},
+ updated_at = #{updatedAt, jdbcType=BIGINT}
+ where
+ id = #{id, jdbcType=BIGINT}
</update>
- <update id="delete" parameterType="int">
- DELETE FROM active_rules WHERE id=#{id}
- </update>
+ <delete id="delete" parameterType="int">
+ delete from active_rules
+ where
+ id=#{id, jdbcType=BIGINT}
+ </delete>
- <update id="deleteByProfileKeys" parameterType="String">
+ <delete id="deleteByRuleProfileUuids" parameterType="String">
delete from active_rules
where exists (
select 1
- from rules_profiles p
- where p.id = profile_id and p.kee in
- <foreach collection="profileKeys" open="(" close=")" item="profileKey" separator=",">#{profileKey, jdbcType=VARCHAR}</foreach>
+ from rules_profiles rp
+ where rp.id = profile_id
+ and rp.kee in
+ <foreach collection="rulesProfileUuids" open="(" close=")" item="rulesProfileUuid" separator=",">#{rulesProfileUuid, jdbcType=VARCHAR}</foreach>
)
- </update>
+ </delete>
<select id="selectByKey" parameterType="map" resultType="ActiveRule">
- SELECT
- <include refid="activeRuleKeyColumns"/>
- FROM active_rules a
+ select
+ <include refid="activeRuleColumns"/>
+ from active_rules a
<include refid="activeRuleKeyJoin"/>
- WHERE
- qp.kee = #{profileKey}
- AND r.plugin_rule_key = #{rule}
- AND r.plugin_name = #{repository}
+ where
+ rp.kee = #{ruleProfileUuid, jdbcType=VARCHAR}
+ and r.plugin_rule_key = #{rule, jdbcType=VARCHAR}
+ and r.plugin_name = #{repository, jdbcType=VARCHAR}
</select>
<select id="selectByKeys" parameterType="map" resultType="ActiveRule">
- SELECT
- <include refid="activeRuleKeyColumns"/>
- FROM active_rules a
+ select
+ <include refid="activeRuleColumns"/>
+ from active_rules a
<include refid="activeRuleKeyJoin"/>
- WHERE
+ where
<foreach collection="keys" item="key" open="(" separator=" or " close=")">
- (qp.kee = #{key.qualityProfileKey}
- AND r.plugin_rule_key = #{key.ruleKey.rule}
- AND r.plugin_name = #{key.ruleKey.repository}
+ (rp.kee = #{key.ruleProfileUuid, jdbcType=VARCHAR}
+ AND r.plugin_rule_key = #{key.ruleKey.rule, jdbcType=VARCHAR}
+ AND r.plugin_name = #{key.ruleKey.repository, jdbcType=VARCHAR}
)
</foreach>
</select>
- <select id="selectByProfileKey" parameterType="string" resultType="ActiveRule">
- SELECT
- <include refid="activeRuleKeyColumns"/>
- FROM active_rules a
- INNER JOIN rules_profiles qp ON qp.id=a.profile_id
- INNER JOIN rules r ON r.id = a.rule_id AND r.status != 'REMOVED'
- where qp.kee=#{id}
+ <select id="selectByProfileUuid" parameterType="string" resultType="org.sonar.db.qualityprofile.OrgActiveRuleDto">
+ select
+ <include refid="orgActiveRuleColumns"/>
+ from active_rules a
+ inner join rules_profiles rp on rp.id = a.profile_id
+ inner join org_qprofiles oqp on oqp.rules_profile_uuid = rp.kee
+ inner join rules r on r.id = a.rule_id and r.status != 'REMOVED'
+ where oqp.uuid = #{id, jdbcType=VARCHAR}
</select>
- <select id="selectByRuleId" parameterType="map" resultType="ActiveRule">
- SELECT
- <include refid="activeRuleKeyColumns"/>
- FROM active_rules a
- <include refid="activeRuleKeyJoin"/>
- WHERE a.rule_id=#{ruleId, jdbcType=BIGINT}
- AND oqp.organization_uuid=#{organizationUuid, jdbcType=VARCHAR}
+ <select id="selectByRuleId" parameterType="map" resultType="org.sonar.db.qualityprofile.OrgActiveRuleDto">
+ select
+ <include refid="orgActiveRuleColumns"/>
+ from active_rules a
+ inner join rules_profiles rp on rp.id = a.profile_id
+ inner join org_qprofiles oqp on oqp.rules_profile_uuid = rp.kee
+ inner join rules r on r.id = a.rule_id
+ where
+ a.rule_id = #{ruleId, jdbcType=BIGINT}
+ and oqp.organization_uuid = #{organizationUuid, jdbcType=VARCHAR}
</select>
<select id="selectByRuleIdOfAllOrganizations" parameterType="Integer" resultType="ActiveRule">
- SELECT
- <include refid="activeRuleKeyColumns"/>
- FROM active_rules a
+ select
+ <include refid="activeRuleColumns"/>
+ from active_rules a
<include refid="activeRuleKeyJoin"/>
- WHERE a.rule_id=#{ruleId}
+ where
+ a.rule_id = #{ruleId, jdbcType=BIGINT}
</select>
- <select id="selectByRuleIds" parameterType="List" resultType="ActiveRule">
- SELECT
- <include refid="activeRuleKeyColumns"/>
- FROM active_rules a
- <include refid="activeRuleKeyJoin"/>
- WHERE
+ <select id="selectByRuleIds" parameterType="List" resultType="org.sonar.db.qualityprofile.OrgActiveRuleDto">
+ select
+ <include refid="orgActiveRuleColumns"/>
+ from active_rules a
+ inner join rules_profiles rp on rp.id = a.profile_id
+ inner join org_qprofiles oqp on oqp.rules_profile_uuid = rp.kee
+ inner join rules r on r.id = a.rule_id
+ where
a.rule_id in
<foreach collection="ruleIds" item="ruleId" separator="," open="(" close=")">
- #{ruleId}
+ #{ruleId, jdbcType=BIGINT}
</foreach>
- AND oqp.organization_uuid=#{organizationUuid, jdbcType=VARCHAR}
+ and oqp.organization_uuid = #{organizationUuid, jdbcType=VARCHAR}
</select>
<!-- Parameters -->
</sql>
<insert id="insertParameter" parameterType="ActiveRuleParam" keyColumn="id" useGeneratedKeys="true" keyProperty="id">
- INSERT INTO active_rule_parameters (active_rule_id, rules_parameter_id, rules_parameter_key, value)
- VALUES (#{activeRuleId}, #{rulesParameterId}, #{key}, #{value})
+ insert into active_rule_parameters (
+ active_rule_id,
+ rules_parameter_id,
+ rules_parameter_key,
+ value
+ ) values (
+ #{activeRuleId, jdbcType=BIGINT},
+ #{rulesParameterId, jdbcType=BIGINT},
+ #{key, jdbcType=VARCHAR},
+ #{value, jdbcType=VARCHAR}
+ )
</insert>
<update id="updateParameter" parameterType="ActiveRuleParam">
UPDATE active_rule_parameters SET
- value=#{value}
- WHERE id=#{id}
+ value=#{value, jdbcType=VARCHAR}
+ WHERE id=#{id, jdbcType=BIGINT}
</update>
- <update id="deleteParameters" parameterType="int">
- DELETE FROM active_rule_parameters WHERE active_rule_id=#{id}
- </update>
+ <delete id="deleteParameters" parameterType="int">
+ DELETE FROM active_rule_parameters WHERE active_rule_id=#{id, jdbcType=BIGINT}
+ </delete>
- <update id="deleteParametersByProfileKeys" parameterType="String">
+ <delete id="deleteParametersByRuleProfileUuids" parameterType="String">
delete from active_rule_parameters
where exists (
select 1 from active_rules ar
- inner join rules_profiles p on p.id = ar.profile_id
+ inner join rules_profiles rp on rp.id = ar.profile_id
where ar.id = active_rule_id
- and p.kee in
- <foreach collection="profileKeys" open="(" close=")" item="profileKey" separator=",">
- #{profileKey, jdbcType=VARCHAR}
+ and rp.kee in
+ <foreach collection="rulesProfileUuids" open="(" close=")" item="rulesProfileUuid" separator=",">
+ #{rulesProfileUuid, jdbcType=VARCHAR}
</foreach>
)
- </update>
+ </delete>
- <update id="deleteParameter" parameterType="int">
- DELETE FROM active_rule_parameters WHERE id=#{id}
- </update>
+ <delete id="deleteParameter" parameterType="int">
+ DELETE FROM active_rule_parameters WHERE id=#{id, jdbcType=BIGINT}
+ </delete>
<select id="selectParamsByActiveRuleId" parameterType="Integer" resultType="ActiveRuleParam">
select
<include refid="activeRuleParamColumns"/>
from active_rule_parameters p
<where>
- p.active_rule_id=#{id}
+ p.active_rule_id=#{id, jdbcType=BIGINT}
</where>
</select>
from active_rule_parameters p
<where>
<foreach collection="ids" item="id" open="(" separator=" or " close=")">
- p.active_rule_id=#{id}
+ p.active_rule_id=#{id, jdbcType=BIGINT}
</foreach>
</where>
</select>
- <select id="selectParamByActiveRuleAndKey" parameterType="map" resultType="ActiveRuleParam">
- SELECT
- <include refid="activeRuleParamColumns"/>
- FROM active_rule_parameters p
- <where>
- AND p.active_rule_id=#{activeRuleId}
- AND p.rules_parameter_key=#{key}
- </where>
- </select>
-
- <select id="selectAllParams" resultType="ActiveRuleParam">
- select
- <include refid="activeRuleParamColumns"/>
- from active_rule_parameters p
- </select>
-
- <select id="countActiveRulesByProfileKey" resultType="KeyLongValue" parameterType="map">
- select rp.kee as "key", count(ar.id) as "value"
+ <select id="countActiveRulesByProfileUuid" resultType="KeyLongValue" parameterType="map">
+ select oqp.uuid as "key", count(ar.id) as "value"
from active_rules ar
inner join rules_profiles rp on rp.id = ar.profile_id
inner join org_qprofiles oqp on oqp.rules_profile_uuid = rp.kee
inner join rules r on r.id = ar.rule_id
where oqp.organization_uuid = #{organizationUuid, jdbcType=VARCHAR}
and r.status != 'REMOVED'
- group by rp.kee
+ group by oqp.uuid
</select>
- <select id="countActiveRulesForRuleStatusByProfileKey" resultType="KeyLongValue" parameterType="map">
- select rp.kee as "key", count(ar.id) as "value"
+ <select id="countActiveRulesForRuleStatusByProfileUuid" resultType="KeyLongValue" parameterType="map">
+ select oqp.uuid as "key", count(ar.id) as "value"
from active_rules ar
inner join rules_profiles rp on rp.id = ar.profile_id
inner join org_qprofiles oqp on oqp.rules_profile_uuid = rp.kee
inner join rules r on r.id = ar.rule_id
where oqp.organization_uuid = #{organizationUuid, jdbcType=VARCHAR}
and r.status = #{ruleStatus, jdbcType=VARCHAR}
- group by rp.kee
+ group by oqp.uuid
</select>
- <select id="countActiveRulesForInheritanceByProfileKey" resultType="KeyLongValue" parameterType="map">
- select rp.kee as "key", count(ar.id) as "value"
+ <select id="countActiveRulesForInheritanceByProfileUuid" resultType="KeyLongValue" parameterType="map">
+ select oqp.uuid as "key", count(ar.id) as "value"
from active_rules ar
inner join rules_profiles rp on rp.id = ar.profile_id
inner join org_qprofiles oqp on oqp.rules_profile_uuid = rp.kee
where oqp.organization_uuid = #{organizationUuid, jdbcType=VARCHAR}
and ar.inheritance = #{inheritance, jdbcType=VARCHAR}
and r.status != 'REMOVED'
- group by rp.kee
+ group by oqp.uuid
</select>
</mapper>
<mapper namespace="org.sonar.db.qualityprofile.QProfileChangeMapper">
+ <sql id="selectColumns">
+ qpc.kee as "uuid",
+ qpc.qprofile_key as rulesProfileUuid,
+ qpc.created_at as createdAt,
+ qpc.user_login as login,
+ qpc.change_type as changeType,
+ qpc.change_data as data
+ </sql>
+
<insert id="insert" useGeneratedKeys="false" parameterType="org.sonar.db.qualityprofile.QProfileChangeDto">
insert into qprofile_changes
(
- kee,
- qprofile_key,
- created_at,
- user_login,
- change_type,
- change_data
+ kee,
+ qprofile_key,
+ created_at,
+ user_login,
+ change_type,
+ change_data
) values (
- #{key,jdbcType=VARCHAR},
- #{profileKey,jdbcType=VARCHAR},
- #{createdAt,jdbcType=BIGINT},
- #{login,jdbcType=VARCHAR},
- #{changeType,jdbcType=VARCHAR},
- #{data,jdbcType=VARCHAR}
+ #{uuid, jdbcType=VARCHAR},
+ #{rulesProfileUuid, jdbcType=VARCHAR},
+ #{createdAt, jdbcType=BIGINT},
+ #{login, jdbcType=VARCHAR},
+ #{changeType, jdbcType=VARCHAR},
+ #{data, jdbcType=VARCHAR}
)
</insert>
- <select id="countForProfileUuid" resultType="int">
- select count(kee) from qprofile_changes
- where qprofile_key = #{profileUuid, jdbcType=VARCHAR}
+ <select id="countForQProfileUuid" resultType="int">
+ select count(qpc.kee)
+ from qprofile_changes qpc
+ inner join rules_profiles rp on rp.kee = qpc.qprofile_key
+ inner join org_qprofiles oqp on oqp.rules_profile_uuid = rp.kee
+ where
+ oqp.uuid = #{qProfileUuid, jdbcType=VARCHAR}
</select>
<select id="selectByQuery" resultType="org.sonar.db.qualityprofile.QProfileChangeDto">
</select>
<select id="selectByQuery" databaseId="oracle" resultType="org.sonar.db.qualityprofile.QProfileChangeDto">
- select "key", profileKey, createdAt, login, changeType, data from (
- select rownum rnum, "key", profileKey, createdAt, login, changeType, data from (
+ select "uuid", rulesProfileUuid, createdAt, login, changeType, data from (
+ select rownum rnum, "uuid", rulesProfileUuid, createdAt, login, changeType, data from (
<include refid="sqlSelectByQuery" />
)
where rownum <= #{query.total}
where rnum > #{query.offset}
</select>
- <sql id="sqlColumns">
- kee as "key",
- qprofile_key as profileKey,
- created_at as createdAt,
- user_login as login,
- change_type as changeType,
- change_data as data
- </sql>
-
<sql id="sqlSelectByQuery">
- select <include refid="sqlColumns" />
- from qprofile_changes
- where qprofile_key = #{query.profileUuid, jdbcType=VARCHAR}
- <if test="query.fromIncluded != null">
- and created_at >= #{query.fromIncluded}
- </if>
- <if test="query.toExcluded != null">
- and created_at < #{query.toExcluded}
- </if>
- order by created_at desc
+ select <include refid="selectColumns" />
+ from qprofile_changes qpc
+ inner join rules_profiles rp on rp.kee = qpc.qprofile_key
+ inner join org_qprofiles oqp on oqp.rules_profile_uuid = rp.kee
+ where
+ oqp.uuid = #{query.profileUuid, jdbcType=VARCHAR}
+ <if test="query.fromIncluded != null">
+ and qpc.created_at >= #{query.fromIncluded}
+ </if>
+ <if test="query.toExcluded != null">
+ and qpc.created_at < #{query.toExcluded}
+ </if>
+ order by qpc.created_at desc
</sql>
- <delete id="deleteByProfileUuids" parameterType="String">
+ <delete id="deleteByRuleProfileUuids" parameterType="String">
delete from qprofile_changes
where qprofile_key in
- <foreach collection="profileUuids" open="(" close=")" item="profileUuid" separator=",">
- #{profileUuid, jdbcType=VARCHAR}
+ <foreach collection="ruleProfileUuids" open="(" close=")" item="ruleProfileUuid" separator=",">
+ #{ruleProfileUuid, jdbcType=VARCHAR}
</foreach>
</delete>
</mapper>
oqp.organization_uuid as organizationUuid,
oqp.parent_uuid as parentKee,
rp.id as id,
+ rp.kee as rulesProfileUuid,
rp.name as name,
rp.language as language,
rp.rules_updated_at as rulesUpdatedAt,
rp.is_built_in as isBuiltIn
</sql>
- <insert id="insertRulesProfile" parameterType="map" keyColumn="id" useGeneratedKeys="true" keyProperty="dto.id">
+ <sql id="ruleProfileColumns">
+ rp.id as id,
+ rp.kee as kee,
+ rp.name as name,
+ rp.language as language,
+ rp.rules_updated_at as rulesUpdatedAt,
+ rp.last_used as lastUsed,
+ rp.user_updated_at as userUpdatedAt,
+ rp.is_built_in as isBuiltIn
+ </sql>
+
+ <insert id="insertRuleProfile" parameterType="map" keyColumn="id" useGeneratedKeys="true" keyProperty="dto.id">
insert into rules_profiles (
kee,
name,
created_at,
updated_at
) values (
- #{dto.kee, jdbcType=VARCHAR},
+ #{dto.uuid, jdbcType=VARCHAR},
#{dto.organizationUuid, jdbcType=VARCHAR},
- #{dto.kee, jdbcType=VARCHAR},
- #{dto.parentKee, jdbcType=VARCHAR},
+ #{dto.rulesProfileUuid, jdbcType=VARCHAR},
+ #{dto.parentUuid, jdbcType=VARCHAR},
#{now, jdbcType=BIGINT},
#{now, jdbcType=BIGINT}
)
</insert>
- <update id="updateRulesProfile" parameterType="map">
+ <update id="updateRuleProfile" parameterType="map">
update rules_profiles
set
name = #{dto.name, jdbcType=VARCHAR},
user_updated_at = #{dto.userUpdatedAt, jdbcType=BIGINT},
is_built_in = #{dto.isBuiltIn, jdbcType=BOOLEAN}
where
- kee = #{dto.kee, jdbcType=VARCHAR}
+ kee = #{dto.rulesProfileUuid, jdbcType=VARCHAR}
</update>
<update id="updateOrgQProfile" parameterType="map">
uuid = #{dto.kee, jdbcType=VARCHAR}
</update>
- <delete id="deleteRulesProfilesByUuids" parameterType="String">
+ <delete id="deleteRuleProfilesByUuids" parameterType="String">
delete from rules_profiles
where kee in
<foreach collection="uuids" open="(" close=")" item="uuid" separator=",">#{uuid, jdbcType=VARCHAR}</foreach>
<foreach collection="uuids" open="(" close=")" item="uuid" separator=",">#{uuid, jdbcType=VARCHAR}</foreach>
</delete>
- <select id="selectAll" parameterType="map" resultType="org.sonar.db.qualityprofile.QProfileDto">
+ <select id="selectBuiltInRuleProfiles" resultType="org.sonar.db.qualityprofile.RulesProfileDto">
+ select <include refid="ruleProfileColumns"/>
+ from rules_profiles rp
+ where rp.is_built_in = ${_true}
+ </select>
+
+ <select id="selectOrderedByOrganizationUuid" parameterType="map" resultType="org.sonar.db.qualityprofile.QProfileDto">
select
<include refid="qProfileColumns"/>
from org_qprofiles oqp
inner join default_qprofiles dp on dp.qprofile_uuid = oqp.uuid
where
dp.language in <foreach collection="languages" open="(" close=")" item="language" separator=",">#{language, jdbcType=VARCHAR}</foreach>
- and dp.organization_uuid = #{organizationUuid, jdbcType=VARCHAR}
+ and dp.organization_uuid = oqp.organization_uuid
and rp.language = dp.language
and oqp.organization_uuid = #{organizationUuid, jdbcType=VARCHAR}
</select>
from org_qprofiles oqp
inner join rules_profiles rp on oqp.rules_profile_uuid = rp.kee
where
- oqp.uuid in <foreach collection="uuids" open="(" close=")" item="uuid" separator=",">#{uuid}</foreach>
+ oqp.uuid in <foreach collection="uuids" open="(" close=")" item="uuid" separator=",">#{uuid, jdbcType=VARCHAR}</foreach>
</select>
<select id="selectByLanguage" parameterType="String" resultType="org.sonar.db.qualityprofile.QProfileDto">
ORDER BY pj.name ASC
</select>
- <select id="selectUuidsOfCustomQProfiles" parameterType="map" resultType="string">
- select oqp.uuid
+ <select id="selectUuidsOfCustomRuleProfiles" parameterType="map" resultType="string">
+ select oqp.rules_profile_uuid
from org_qprofiles oqp
inner join organizations o on o.uuid = oqp.organization_uuid
inner join rules_profiles rp on rp.kee = oqp.rules_profile_uuid
and rp.is_built_in = ${_false}
</select>
- <update id="renameRulesProfiles" parameterType="map">
+ <update id="renameRuleProfiles" parameterType="map">
update rules_profiles
set
name = #{newName, jdbcType=VARCHAR},
@Override
protected void after() {
if (session != null) {
+ session.rollback();
session.close();
}
db.stop();
import org.sonar.db.DbTester;
import org.sonar.db.dialect.Dialect;
import org.sonar.db.dialect.Oracle;
-import org.sonar.db.qualityprofile.QProfileDto;
import org.sonar.db.user.GroupDto;
import org.sonar.db.user.GroupTesting;
import org.sonar.db.user.UserDto;
.containsOnlyOnce(organization.getUuid());
}
- @Test
- public void selectWithoutQualityProfile_returns_() {
- OrganizationDto orgWithoutAnyProfiles = dbTester.organizations().insert();
- OrganizationDto orgWithProfiles = dbTester.organizations().insert();
- QProfileDto profile = dbTester.qualityProfiles().insert(orgWithProfiles);
-
- assertThat(underTest.selectWithoutQualityProfile(dbSession, "js", "foo"))
- .extracting(OrganizationDto::getUuid).containsExactlyInAnyOrder(orgWithoutAnyProfiles.getUuid(), orgWithProfiles.getUuid());
-
- assertThat(underTest.selectWithoutQualityProfile(dbSession, profile.getLanguage(), profile.getName()))
- .extracting(OrganizationDto::getUuid).containsExactlyInAnyOrder(orgWithoutAnyProfiles.getUuid());
- }
-
private void expectDtoCanNotBeNull() {
expectedException.expect(NullPointerException.class);
expectedException.expectMessage("OrganizationDto can't be null");
import java.util.Collections;
import java.util.List;
import java.util.Map;
-import org.junit.After;
+import java.util.Objects;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.sonar.api.rule.RuleStatus;
+import org.sonar.api.rule.Severity;
import org.sonar.api.server.rule.RuleParamType;
import org.sonar.api.utils.System2;
-import org.sonar.db.DbClient;
+import org.sonar.api.utils.internal.TestSystem2;
import org.sonar.db.DbSession;
import org.sonar.db.DbTester;
-import org.sonar.db.RowNotFoundException;
import org.sonar.db.organization.OrganizationDto;
import org.sonar.db.organization.OrganizationTesting;
import org.sonar.db.rule.RuleDefinitionDto;
import static java.util.Arrays.asList;
import static java.util.Collections.emptyList;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.tuple;
import static org.assertj.core.data.MapEntry.entry;
-import static org.assertj.guava.api.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
import static org.sonar.api.rule.Severity.BLOCKER;
import static org.sonar.api.rule.Severity.MAJOR;
import static org.sonar.db.qualityprofile.ActiveRuleDto.INHERITED;
private static final long NOW = 10_000_000L;
- private OrganizationDto organization = OrganizationTesting.newOrganizationDto();
-
- private QProfileDto profile1 = QProfileDto.createFor("qp1").setOrganizationUuid(organization.getUuid()).setName("QProfile1");
- private QProfileDto profile2 = QProfileDto.createFor("qp2").setOrganizationUuid(organization.getUuid()).setName("QProfile2");
-
- private RuleDefinitionDto rule1 = RuleTesting.newRule(RuleTesting.XOO_X1);
- private RuleDefinitionDto rule2 = RuleTesting.newRule(RuleTesting.XOO_X2);
- private RuleDefinitionDto rule3 = RuleTesting.newRule(RuleTesting.XOO_X3);
- private RuleDefinitionDto removedRule = RuleTesting.newRule().setStatus(RuleStatus.REMOVED);
-
+ private OrganizationDto organization;
+ private QProfileDto profile1;
+ private QProfileDto profile2;
+ private RuleDefinitionDto rule1;
+ private RuleDefinitionDto rule2;
+ private RuleDefinitionDto rule3;
+ private RuleDefinitionDto removedRule;
private RuleParamDto rule1Param1;
private RuleParamDto rule1Param2;
private RuleParamDto rule2Param1;
-
- private System2 system = mock(System2.class);
+ private System2 system = new TestSystem2().setNow(NOW);
@Rule
- public DbTester dbTester = DbTester.create(system);
+ public DbTester db = DbTester.create(system);
- private DbClient dbClient = dbTester.getDbClient();
- private DbSession dbSession = dbTester.getSession();
+ private DbSession dbSession = db.getSession();
- private ActiveRuleDao underTest = dbTester.getDbClient().activeRuleDao();
+ private ActiveRuleDao underTest = db.getDbClient().activeRuleDao();
@Before
public void setUp() {
- when(system.now()).thenReturn(NOW);
-
- dbClient.qualityProfileDao().insert(dbSession, profile1);
- dbClient.qualityProfileDao().insert(dbSession, profile2);
- dbTester.rules().insert(rule1);
- dbTester.rules().insert(rule2);
- dbTester.rules().insert(rule3);
- dbTester.rules().insert(removedRule);
+ organization = db.organizations().insert();
+ profile1 = db.qualityProfiles().insert(organization);
+ profile2 = db.qualityProfiles().insert(organization);
+ rule1 = db.rules().insert();
+ rule2 = db.rules().insert();
+ rule3 = db.rules().insert();
+ removedRule = db.rules().insert(r -> r.setStatus(RuleStatus.REMOVED));
rule1Param1 = new RuleParamDto()
.setName("param1")
.setDefaultValue("value1")
.setType(RuleParamType.STRING.toString());
- dbClient.ruleDao().insertRuleParam(dbSession, rule1, rule1Param1);
-
- rule1Param2 = new RuleParamDto()
- .setRuleId(rule1.getId())
- .setName("param2")
- .setDefaultValue("2")
- .setType(RuleParamType.INTEGER.toString());
- dbClient.ruleDao().insertRuleParam(dbSession, rule1, rule1Param2);
-
- rule2Param1 = new RuleParamDto()
- .setRuleId(rule2.getId())
- .setName("param1")
- .setDefaultValue("1")
- .setType(RuleParamType.INTEGER.toString());
- dbClient.ruleDao().insertRuleParam(dbSession, rule2, rule2Param1);
-
- dbSession.commit();
- }
-
- @After
- public void tearDown() {
- // minor optimization, no need to commit pending operations
- dbSession.rollback();
+ rule1Param1 = db.rules().insertRuleParam(rule1);
+ rule1Param2 = db.rules().insertRuleParam(rule1);
+ rule2Param1 = db.rules().insertRuleParam(rule2);
}
@Test
- public void select_by_key() {
+ public void selectByKey() {
ActiveRuleDto activeRule = createFor(profile1, rule1).setSeverity(BLOCKER);
underTest.insert(dbSession, activeRule);
assertThat(underTest.selectByKey(dbSession, activeRule.getKey())).isPresent();
- assertThat(underTest.selectByKey(dbSession, ActiveRuleKey.of(profile2.getKee(), rule2.getKey()))).isAbsent();
- }
-
- @Test
- public void select_or_fail_by_key() {
- ActiveRuleDto activeRule = createFor(profile1, rule1).setSeverity(BLOCKER);
- underTest.insert(dbSession, activeRule);
-
- assertThat(underTest.selectOrFailByKey(dbSession, activeRule.getKey())).isNotNull();
-
- thrown.expect(RowNotFoundException.class);
- thrown.expectMessage("Active rule with key 'qp2:xoo:x2' does not exist");
- underTest.selectOrFailByKey(dbSession, ActiveRuleKey.of(profile2.getKee(), rule2.getKey()));
+ assertThat(underTest.selectByKey(dbSession, ActiveRuleKey.of(profile2, rule2.getKey()))).isEmpty();
}
@Test
public void select_by_rule() {
ActiveRuleDto activeRule1 = createFor(profile1, rule1).setSeverity(BLOCKER);
ActiveRuleDto activeRule2 = createFor(profile2, rule1).setSeverity(BLOCKER);
- underTest.insert(dbTester.getSession(), activeRule1);
- underTest.insert(dbTester.getSession(), activeRule2);
+ underTest.insert(dbSession, activeRule1);
+ underTest.insert(dbSession, activeRule2);
dbSession.commit();
assertThat(underTest.selectByRuleId(dbSession, organization, rule1.getId())).extracting("key").containsOnly(activeRule1.getKey(), activeRule2.getKey());
underTest.insert(dbSession, activeRule3);
dbSession.commit();
- assertThat(underTest.selectByRuleIds(dbSession, organization.getUuid(), Collections.singletonList(rule1.getId())))
+ assertThat(underTest.selectByRuleIds(dbSession, organization, Collections.singletonList(rule1.getId())))
.extracting("key").containsOnly(activeRule1.getKey(), activeRule3.getKey());
- assertThat(underTest.selectByRuleIds(dbSession, organization.getUuid(), newArrayList(rule1.getId(), rule2.getId())))
+ assertThat(underTest.selectByRuleIds(dbSession, organization, newArrayList(rule1.getId(), rule2.getId())))
.extracting("key").containsOnly(activeRule1.getKey(), activeRule2.getKey(), activeRule3.getKey());
}
@Test
- public void select_by_profile() {
+ public void selectByProfile() {
ActiveRuleDto activeRule1 = createFor(profile1, rule1).setSeverity(BLOCKER);
ActiveRuleDto activeRule2 = createFor(profile1, rule2).setSeverity(BLOCKER);
- underTest.insert(dbTester.getSession(), activeRule1);
- underTest.insert(dbTester.getSession(), activeRule2);
- dbSession.commit();
+ underTest.insert(dbSession, activeRule1);
+ underTest.insert(dbSession, activeRule2);
- assertThat(underTest.selectByProfileKey(dbSession, profile1.getKee())).hasSize(2);
- assertThat(underTest.selectByProfileKey(dbSession, profile2.getKee())).isEmpty();
+ List<OrgActiveRuleDto> result = underTest.selectByProfile(dbSession, profile1);
+ assertThat(result)
+ .hasSize(2)
+ .extracting(OrgActiveRuleDto::getOrganizationUuid, OrgActiveRuleDto::getProfileUuid, OrgActiveRuleDto::getProfileId)
+ .containsOnly(tuple(organization.getUuid(), profile1.getKee(), profile1.getId()));
+
+ assertThat(underTest.selectByProfile(dbSession, profile2)).isEmpty();
}
@Test
- public void select_by_profile_ignore_removed_rules() throws Exception {
+ public void selectByProfileUuid_ignores_removed_rules() throws Exception {
ActiveRuleDto activeRule = createFor(profile1, removedRule).setSeverity(BLOCKER);
- underTest.insert(dbTester.getSession(), activeRule);
- dbSession.commit();
+ underTest.insert(dbSession, activeRule);
- assertThat(underTest.selectByProfileKey(dbSession, profile1.getKee())).isEmpty();
+ assertThat(underTest.selectByProfile(dbSession, profile1)).isEmpty();
}
@Test
.setInheritance(INHERITED)
.setCreatedAt(1000L)
.setUpdatedAt(2000L);
- underTest.insert(dbTester.getSession(), activeRule);
+ underTest.insert(dbSession, activeRule);
dbSession.commit();
- ActiveRuleDto result = underTest.selectOrFailByKey(dbSession, activeRule.getKey());
+ ActiveRuleDto result = underTest.selectByKey(dbSession, activeRule.getKey()).get();
assertThat(result.getId()).isEqualTo(activeRule.getId());
- assertThat(result.getKey()).isEqualTo(ActiveRuleKey.of(profile1.getKee(), rule1.getKey()));
+ assertThat(result.getKey()).isEqualTo(ActiveRuleKey.of(profile1, rule1.getKey()));
assertThat(result.getRuleId()).isEqualTo(rule1.getId());
assertThat(result.getProfileId()).isEqualTo(profile1.getId());
assertThat(result.getSeverityString()).isEqualTo(BLOCKER);
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("Quality profile is not persisted (missing id)");
- underTest.insert(dbTester.getSession(), createFor(profile1, rule1).setProfileId(null));
+ underTest.insert(dbSession, createFor(profile1, rule1).setProfileId(null));
}
@Test
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("Rule is not persisted");
- underTest.insert(dbTester.getSession(), createFor(profile1, rule1).setRuleId(null));
+ underTest.insert(dbSession, createFor(profile1, rule1).setRuleId(null));
}
@Test
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("ActiveRule is already persisted");
- underTest.insert(dbTester.getSession(), createFor(profile1, rule1).setId(100));
+ underTest.insert(dbSession, createFor(profile1, rule1).setId(100));
}
@Test
.setInheritance(INHERITED)
.setCreatedAt(1000L)
.setUpdatedAt(2000L);
- underTest.insert(dbTester.getSession(), activeRule);
+ underTest.insert(dbSession, activeRule);
dbSession.commit();
ActiveRuleDto activeRuleUpdated = activeRule
// created at should not be updated
.setCreatedAt(3000L)
.setUpdatedAt(4000L);
- underTest.update(dbTester.getSession(), activeRuleUpdated);
+ underTest.update(dbSession, activeRuleUpdated);
dbSession.commit();
- ActiveRuleDto result = underTest.selectOrFailByKey(dbSession, ActiveRuleKey.of(profile1.getKee(), rule1.getKey()));
+ ActiveRuleDto result = underTest.selectByKey(dbSession, ActiveRuleKey.of(profile1, rule1.getKey())).get();
assertThat(result.getId()).isEqualTo(activeRule.getId());
- assertThat(result.getKey()).isEqualTo(ActiveRuleKey.of(profile1.getKee(), rule1.getKey()));
+ assertThat(result.getKey()).isEqualTo(ActiveRuleKey.of(profile1, rule1.getKey()));
assertThat(result.getRuleId()).isEqualTo(rule1.getId());
assertThat(result.getProfileId()).isEqualTo(profile1.getId());
assertThat(result.getSeverityString()).isEqualTo(MAJOR);
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("Quality profile is not persisted (missing id)");
- underTest.update(dbTester.getSession(), createFor(profile1, rule1).setId(100).setProfileId(null));
+ underTest.update(dbSession, createFor(profile1, rule1).setId(100).setProfileId(null));
}
@Test
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("Rule is not persisted");
- underTest.update(dbTester.getSession(), createFor(profile1, rule1).setId(100).setRuleId(null));
+ underTest.update(dbSession, createFor(profile1, rule1).setId(100).setRuleId(null));
}
@Test
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("ActiveRule is not persisted");
- underTest.update(dbTester.getSession(), createFor(profile1, rule1).setId(null));
+ underTest.update(dbSession, createFor(profile1, rule1).setId(null));
}
@Test
underTest.delete(dbSession, activeRule.getKey());
- assertThat(underTest.selectByKey(dbSession, ActiveRuleKey.of(profile1.getKee(), rule1.getKey()))).isAbsent();
+ assertThat(underTest.selectByKey(dbSession, ActiveRuleKey.of(profile1, rule1.getKey()))).isEmpty();
}
@Test
public void delete_does_not_fail_when_active_rule_does_not_exist() {
- underTest.delete(dbSession, ActiveRuleKey.of(profile1.getKee(), rule1.getKey()));
+ underTest.delete(dbSession, ActiveRuleKey.of(profile1, rule1.getKey()));
}
@Test
- public void deleteByKeys_deletes_rows_from_table() {
+ public void deleteByRuleProfileUuids_deletes_rows_from_table() {
underTest.insert(dbSession, newRow(profile1, rule1));
underTest.insert(dbSession, newRow(profile1, rule2));
underTest.insert(dbSession, newRow(profile2, rule1));
- underTest.deleteByProfileKeys(dbSession, asList(profile1.getKee()));
+ underTest.deleteByRuleProfileUuids(dbSession, asList(profile1.getRulesProfileUuid()));
- assertThat(dbTester.countRowsOfTable(dbSession, "active_rules")).isEqualTo(1);
- assertThat(underTest.selectByKey(dbSession, ActiveRuleKey.of(profile2.getKee(), rule1.getKey()))).isPresent();
+ assertThat(db.countRowsOfTable(dbSession, "active_rules")).isEqualTo(1);
+ assertThat(underTest.selectByKey(dbSession, ActiveRuleKey.of(profile2, rule1.getKey()))).isPresent();
}
@Test
- public void deleteByKeys_does_not_fail_when_profile_with_specified_key_does_not_exist() {
+ public void deleteByRuleProfileUuids_does_not_fail_when_rules_profile_with_specified_key_does_not_exist() {
underTest.insert(dbSession, newRow(profile1, rule1));
- underTest.deleteByProfileKeys(dbSession, asList("does_not_exist"));
+ underTest.deleteByRuleProfileUuids(dbSession, asList("does_not_exist"));
- assertThat(dbTester.countRowsOfTable(dbSession, "active_rules")).isEqualTo(1);
+ assertThat(db.countRowsOfTable(dbSession, "active_rules")).isEqualTo(1);
}
private static ActiveRuleDto newRow(QProfileDto profile, RuleDefinitionDto rule) {
@Test
public void select_params_by_active_rule_id() {
ActiveRuleDto activeRule = createFor(profile1, rule1).setSeverity(BLOCKER);
- underTest.insert(dbTester.getSession(), activeRule);
+ underTest.insert(dbSession, activeRule);
ActiveRuleParamDto activeRuleParam1 = ActiveRuleParamDto.createFor(rule1Param1);
underTest.insertParam(dbSession, activeRule, activeRuleParam1);
ActiveRuleParamDto activeRuleParam2 = ActiveRuleParamDto.createFor(rule1Param2);
@Test
public void select_params_by_active_rule_ids() {
ActiveRuleDto activeRule1 = createFor(profile1, rule1).setSeverity(BLOCKER);
- underTest.insert(dbTester.getSession(), activeRule1);
+ underTest.insert(dbSession, activeRule1);
underTest.insertParam(dbSession, activeRule1, ActiveRuleParamDto.createFor(rule1Param1));
underTest.insertParam(dbSession, activeRule1, ActiveRuleParamDto.createFor(rule1Param2));
ActiveRuleDto activeRule2 = createFor(profile1, rule2).setSeverity(BLOCKER);
- underTest.insert(dbTester.getSession(), activeRule2);
+ underTest.insert(dbSession, activeRule2);
underTest.insertParam(dbSession, activeRule2, ActiveRuleParamDto.createFor(rule2Param1));
dbSession.commit();
}
@Test
- public void select_param_by_key_and_name() {
- ActiveRuleDto activeRule = createFor(profile1, rule1).setSeverity(BLOCKER);
- underTest.insert(dbTester.getSession(), activeRule);
- ActiveRuleParamDto activeRuleParam1 = ActiveRuleParamDto.createFor(rule1Param1).setValue("activeValue1");
- underTest.insertParam(dbSession, activeRule, activeRuleParam1);
- underTest.insertParam(dbSession, activeRule, ActiveRuleParamDto.createFor(rule1Param2));
- dbSession.commit();
-
- assertThat(underTest.selectParamByKeyAndName(activeRule.getKey(), activeRuleParam1.getKey(), dbSession)).isNotNull();
-
- assertThat(underTest.selectParamByKeyAndName(activeRule.getKey(), "unknown", dbSession)).isNull();
- assertThat(underTest.selectParamByKeyAndName(ActiveRuleKey.of(profile2.getKee(), rule1.getKey()), "unknown", dbSession)).isNull();
- }
-
- @Test
- public void select_all_params() {
- ActiveRuleDto activeRule1 = createFor(profile1, rule1).setSeverity(BLOCKER);
- underTest.insert(dbTester.getSession(), activeRule1);
- underTest.insertParam(dbSession, activeRule1, ActiveRuleParamDto.createFor(rule1Param1));
- underTest.insertParam(dbSession, activeRule1, ActiveRuleParamDto.createFor(rule1Param2));
-
- ActiveRuleDto activeRule2 = createFor(profile1, rule2).setSeverity(BLOCKER);
- underTest.insert(dbTester.getSession(), activeRule2);
- underTest.insertParam(dbSession, activeRule2, ActiveRuleParamDto.createFor(rule2Param1));
- dbSession.commit();
-
- assertThat(underTest.selectAllParams(dbSession)).hasSize(3);
- }
-
- @Test
- public void insert_param() {
- ActiveRuleDto activeRule = createFor(profile1, rule1).setSeverity(BLOCKER);
- underTest.insert(dbTester.getSession(), activeRule);
- ActiveRuleParamDto activeRuleParam1 = ActiveRuleParamDto.createFor(rule1Param1).setValue("activeValue1");
- underTest.insertParam(dbSession, activeRule, activeRuleParam1);
- dbSession.commit();
+ public void insertParam() {
+ ActiveRuleDto activeRule = createFor(profile1, rule1).setSeverity(Severity.CRITICAL);
+ underTest.insert(dbSession, activeRule);
- ActiveRuleParamDto result = underTest.selectParamByKeyAndName(activeRule.getKey(), activeRuleParam1.getKey(), dbSession);
- assertThat(result).isNotNull();
+ ActiveRuleParamDto activeRuleParam = ActiveRuleParamDto.createFor(rule1Param1).setValue("foo");
+ underTest.insertParam(dbSession, activeRule, activeRuleParam);
- assertThat(result.getId()).isEqualTo(activeRuleParam1.getId());
- assertThat(result.getKey()).isEqualTo(activeRuleParam1.getKey());
- assertThat(result.getActiveRuleId()).isEqualTo(activeRule.getId());
- assertThat(result.getRulesParameterId()).isEqualTo(rule1Param1.getId());
- assertThat(result.getValue()).isEqualTo("activeValue1");
+ List<ActiveRuleParamDto> reloaded = underTest.selectParamsByActiveRuleId(dbSession, activeRule.getId());
+ assertThat(reloaded).hasSize(1);
+ assertThat(reloaded.get(0))
+ .matches(p -> Objects.equals(p.getId(), activeRuleParam.getId()))
+ .matches(p -> p.getKey().equals(activeRuleParam.getKey()))
+ .matches(p -> p.getActiveRuleId().equals(activeRule.getId()))
+ .matches(p -> p.getRulesParameterId().equals(rule1Param1.getId()))
+ .matches(p -> p.getValue().equals("foo"));
}
@Test
- public void fail_to_insert_param_when_active_rule_id_is_null() {
+ public void insertParam_fails_when_active_rule_id_is_null() {
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("ActiveRule is not persisted");
- underTest.insertParam(dbTester.getSession(),
+ underTest.insertParam(dbSession,
createFor(profile1, rule1).setId(null),
ActiveRuleParamDto.createFor(rule1Param1).setValue("activeValue1"));
}
@Test
- public void fail_to_insert_param_when_active_rule_param_id_is_null() {
+ public void insertParam_fails_when_active_rule_param_id_is_null() {
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("ActiveRuleParam is already persisted");
- underTest.insertParam(dbTester.getSession(),
+ underTest.insertParam(dbSession,
createFor(profile1, rule1).setId(100),
ActiveRuleParamDto.createFor(rule1Param1).setValue("activeValue1").setId(100));
}
@Test
- public void fail_to_insert_param_when_id_is_not_null() {
+ public void insertParam_fails_when_id_is_not_null() {
thrown.expect(NullPointerException.class);
thrown.expectMessage("Rule param is not persisted");
- underTest.insertParam(dbTester.getSession(),
+ underTest.insertParam(dbSession,
createFor(profile1, rule1).setId(100),
ActiveRuleParamDto.createFor(rule1Param1).setValue("activeValue1").setRulesParameterId(null));
}
@Test
- public void update_param() {
- ActiveRuleDto activeRule = createFor(profile1, rule1).setSeverity(BLOCKER);
- underTest.insert(dbTester.getSession(), activeRule);
- ActiveRuleParamDto activeRuleParam1 = ActiveRuleParamDto.createFor(rule1Param1).setValue("activeValue");
- underTest.insertParam(dbSession, activeRule, activeRuleParam1);
- dbSession.commit();
+ public void updateParam() {
+ ActiveRuleDto activeRule = createFor(profile1, rule1).setSeverity(Severity.CRITICAL);
+ underTest.insert(dbSession, activeRule);
+ ActiveRuleParamDto activeRuleParam = ActiveRuleParamDto.createFor(rule1Param1).setValue("foo");
+ underTest.insertParam(dbSession, activeRule, activeRuleParam);
- underTest.updateParam(dbSession, activeRule, activeRuleParam1.setValue("updatedActiveValue"));
- dbSession.commit();
+ underTest.updateParam(dbSession, activeRuleParam.setValue("bar"));
- ActiveRuleParamDto result = underTest.selectParamByKeyAndName(activeRule.getKey(), activeRuleParam1.getKey(), dbSession);
- assertThat(result.getId()).isEqualTo(activeRuleParam1.getId());
- assertThat(result.getKey()).isEqualTo(activeRuleParam1.getKey());
- assertThat(result.getActiveRuleId()).isEqualTo(activeRule.getId());
- assertThat(result.getRulesParameterId()).isEqualTo(rule1Param1.getId());
- assertThat(result.getValue()).isEqualTo("updatedActiveValue");
+ List<ActiveRuleParamDto> reloaded = underTest.selectParamsByActiveRuleId(dbSession, activeRule.getId());
+ assertThat(reloaded).hasSize(1);
+ assertThat(reloaded.get(0))
+ .matches(p -> Objects.equals(p.getId(), activeRuleParam.getId()))
+ .matches(p -> p.getKey().equals(activeRuleParam.getKey()))
+ .matches(p -> p.getActiveRuleId().equals(activeRule.getId()))
+ .matches(p -> p.getRulesParameterId().equals(rule1Param1.getId()))
+ .matches(p -> p.getValue().equals("bar"));
}
@Test
ActiveRuleParamDto param = ActiveRuleParamDto.createFor(rule1Param1).setValue("foo");
underTest.insertParam(dbSession, activeRule, param);
- underTest.deleteParam(dbSession, activeRule, param);
+ underTest.deleteParam(dbSession, param);
- assertThat(underTest.selectParamByKeyAndName(activeRule.getKey(), param.getKey(), dbSession)).isNull();
+ assertThat(underTest.selectParamsByActiveRuleId(dbSession, activeRule.getId())).hasSize(0);
}
@Test
- public void deleteParametersByProfileKeys_deletes_rows_by_profile_keys() {
+ public void deleteParametersByRuleProfileUuids_deletes_rows_by_rule_profile_uuids() {
ActiveRuleDto activeRuleInProfile1 = newRow(profile1, rule1);
underTest.insert(dbSession, activeRuleInProfile1);
ActiveRuleParamDto param1 = ActiveRuleParamDto.createFor(rule1Param1).setValue("foo");
ActiveRuleParamDto param2 = ActiveRuleParamDto.createFor(rule1Param1).setValue("bar");
underTest.insertParam(dbSession, activeRuleInProfile2, param2);
- underTest.deleteParametersByProfileKeys(dbSession, asList(profile1.getKee(), "does_not_exist"));
+ underTest.deleteParametersByRuleProfileUuids(dbSession, asList(profile1.getRulesProfileUuid(), "does_not_exist"));
- List<ActiveRuleParamDto> params = underTest.selectAllParams(dbSession);
- assertThat(params).hasSize(1);
- assertThat(params.get(0).getActiveRuleId()).isEqualTo(activeRuleInProfile2.getId());
+ assertThat(underTest.selectParamsByActiveRuleId(dbSession, activeRuleInProfile1.getId())).isEmpty();
+ assertThat(underTest.selectParamsByActiveRuleId(dbSession, activeRuleInProfile2.getId()))
+ .extracting(ActiveRuleParamDto::getKey, ActiveRuleParamDto::getValue)
+ .containsExactly(tuple(rule1Param1.getName(), "bar"));
}
@Test
- public void deleteParametersByProfileKeys_does_nothing_if_keys_are_empty() {
+ public void deleteParametersByRuleProfileUuids_does_nothing_if_keys_are_empty() {
ActiveRuleDto activeRuleInProfile1 = newRow(profile1, rule1);
underTest.insert(dbSession, activeRuleInProfile1);
ActiveRuleParamDto param1 = ActiveRuleParamDto.createFor(rule1Param1).setValue("foo");
underTest.insertParam(dbSession, activeRuleInProfile1, param1);
- underTest.deleteParametersByProfileKeys(dbSession, emptyList());
-
- List<ActiveRuleParamDto> params = underTest.selectAllParams(dbSession);
- assertThat(params).hasSize(1);
- assertThat(params.get(0).getActiveRuleId()).isEqualTo(activeRuleInProfile1.getId());
- }
-
- @Test
- public void deleteParamByKeyAndName_deletes_rows_by_key_and_name() {
- ActiveRuleDto activeRule = createFor(profile1, rule1).setSeverity(BLOCKER);
- underTest.insert(dbTester.getSession(), activeRule);
- ActiveRuleParamDto activeRuleParam1 = ActiveRuleParamDto.createFor(rule1Param1).setValue("activeValue1");
- underTest.insertParam(dbSession, activeRule, activeRuleParam1);
- dbSession.commit();
-
- underTest.deleteParamByKeyAndName(dbSession, activeRule.getKey(), rule1Param1.getName());
- dbSession.commit();
+ underTest.deleteParametersByRuleProfileUuids(dbSession, emptyList());
- assertThat(underTest.selectParamByKeyAndName(activeRule.getKey(), activeRuleParam1.getKey(), dbSession)).isNull();
+ assertThat(underTest.selectParamsByActiveRuleId(dbSession, activeRuleInProfile1.getId()))
+ .hasSize(1);
}
@Test
- public void does_not_fail_to_delete_param_by_key_and_name_when_active_rule_does_not_exist() {
- underTest.deleteParamByKeyAndName(dbSession, ActiveRuleKey.of(profile1.getKee(), rule1.getKey()), rule1Param1.getName());
- }
-
- @Test
- public void does_not_fail_to_delete_param_by_key_and_name_when_active_rule_param_does_not_exist() {
- ActiveRuleDto activeRule = createFor(profile1, rule1).setSeverity(BLOCKER);
- underTest.insert(dbTester.getSession(), activeRule);
- ActiveRuleParamDto activeRuleParam1 = ActiveRuleParamDto.createFor(rule1Param1).setValue("activeValue1");
- underTest.insertParam(dbSession, activeRule, activeRuleParam1);
- dbSession.commit();
-
- underTest.deleteParamByKeyAndName(dbSession, activeRule.getKey(), "unknown");
- }
-
- @Test
- public void delete_param_by_rule_param() {
+ public void deleteParamsByRuleParamOfAllOrganizations() {
ActiveRuleDto activeRule1 = createFor(profile1, rule1).setSeverity(BLOCKER);
- underTest.insert(dbTester.getSession(), activeRule1);
- ActiveRuleParamDto activeRuleParam1 = ActiveRuleParamDto.createFor(rule1Param1).setValue("activeValue1");
+ underTest.insert(dbSession, activeRule1);
+ ActiveRuleParamDto activeRuleParam1 = ActiveRuleParamDto.createFor(rule1Param1).setValue("foo");
underTest.insertParam(dbSession, activeRule1, activeRuleParam1);
ActiveRuleDto activeRule2 = createFor(profile2, rule1).setSeverity(BLOCKER);
- underTest.insert(dbTester.getSession(), activeRule2);
- ActiveRuleParamDto activeRuleParam2 = ActiveRuleParamDto.createFor(rule1Param1).setValue("activeValue2");
+ underTest.insert(dbSession, activeRule2);
+ ActiveRuleParamDto activeRuleParam2 = ActiveRuleParamDto.createFor(rule1Param1).setValue("bar");
underTest.insertParam(dbSession, activeRule2, activeRuleParam2);
- dbSession.commit();
+ List<Integer> activeRuleIds = asList(activeRule1.getId(), activeRule2.getId());
+ assertThat(underTest.selectParamsByActiveRuleIds(dbSession, activeRuleIds)).hasSize(2);
- underTest.deleteParamsByRuleParamOfAllOrganizations(dbSession, rule1.getId(), rule1Param1.getName());
- dbSession.commit();
-
- assertThat(underTest.selectParamByKeyAndName(activeRule1.getKey(), activeRuleParam1.getKey(), dbSession)).isNull();
- assertThat(underTest.selectParamByKeyAndName(activeRule2.getKey(), activeRuleParam2.getKey(), dbSession)).isNull();
- }
-
- @Test
- public void does_not_fail_to_delete_param_by_rule_param_when_active_param_name_not_found() {
- ActiveRuleDto activeRule1 = createFor(profile1, rule1).setSeverity(BLOCKER);
- underTest.insert(dbTester.getSession(), activeRule1);
- ActiveRuleParamDto activeRuleParam1 = ActiveRuleParamDto.createFor(rule1Param1).setValue("activeValue1");
- underTest.insertParam(dbSession, activeRule1, activeRuleParam1);
-
- ActiveRuleDto activeRule2 = createFor(profile2, rule1).setSeverity(BLOCKER);
- underTest.insert(dbTester.getSession(), activeRule2);
- ActiveRuleParamDto activeRuleParam2 = ActiveRuleParamDto.createFor(rule1Param1).setValue("activeValue2");
- underTest.insertParam(dbSession, activeRule2, activeRuleParam2);
-
- dbSession.commit();
+ underTest.deleteParamsByRuleParamOfAllOrganizations(dbSession, rule1Param1);
- underTest.deleteParamsByRuleParamOfAllOrganizations(dbSession, rule1.getId(), "unknown");
+ assertThat(underTest.selectParamsByActiveRuleIds(dbSession, activeRuleIds)).isEmpty();
}
@Test
public void test_countActiveRulesByProfileKey_for_a_specified_organization() {
- dbTester.qualityProfiles().activateRule(profile1, rule1);
- dbTester.qualityProfiles().activateRule(profile1, rule2);
- dbTester.qualityProfiles().activateRule(profile2, rule1);
+ db.qualityProfiles().activateRule(profile1, rule1);
+ db.qualityProfiles().activateRule(profile1, rule2);
+ db.qualityProfiles().activateRule(profile2, rule1);
- Map<String, Long> counts = underTest.countActiveRulesByProfileKey(dbSession, organization);
+ Map<String, Long> counts = underTest.countActiveRulesByProfileUuid(dbSession, organization);
assertThat(counts).containsOnly(
entry(profile1.getKee(), 2L),
@Test
public void countActiveRulesByProfileKey_returns_empty_map_if_organization_does_not_exist() {
- Map<String, Long> counts = underTest.countActiveRulesByProfileKey(dbSession, OrganizationTesting.newOrganizationDto());
+ Map<String, Long> counts = underTest.countActiveRulesByProfileUuid(dbSession, OrganizationTesting.newOrganizationDto());
assertThat(counts).isEmpty();
}
@Test
public void countActiveRulesByProfileKey_returns_empty_map_if_profile_does_not_have_active_rules() {
- Map<String, Long> counts = underTest.countActiveRulesByProfileKey(dbSession, organization);
+ Map<String, Long> counts = underTest.countActiveRulesByProfileUuid(dbSession, organization);
assertThat(counts).isEmpty();
}
@Test
public void countActiveRulesByProfileKey_ignores_removed_rules() {
- dbTester.qualityProfiles().activateRule(profile1, rule1);
- dbTester.qualityProfiles().activateRule(profile1, removedRule);
+ db.qualityProfiles().activateRule(profile1, rule1);
+ db.qualityProfiles().activateRule(profile1, removedRule);
- Map<String, Long> counts = underTest.countActiveRulesByProfileKey(dbSession, organization);
+ Map<String, Long> counts = underTest.countActiveRulesByProfileUuid(dbSession, organization);
assertThat(counts).containsExactly(entry(profile1.getKee(), 1L));
}
@Test
public void test_countActiveRulesForRuleStatusByProfileKey_for_a_specified_organization() {
- RuleDefinitionDto betaRule1 = dbTester.rules().insertRule(RuleTesting.newRuleDto().setStatus(RuleStatus.BETA)).getDefinition();
- RuleDefinitionDto betaRule2 = dbTester.rules().insertRule(RuleTesting.newRuleDto().setStatus(RuleStatus.BETA)).getDefinition();
- dbTester.qualityProfiles().activateRule(profile1, rule1);
- dbTester.qualityProfiles().activateRule(profile2, betaRule1);
- dbTester.qualityProfiles().activateRule(profile2, betaRule2);
+ RuleDefinitionDto betaRule1 = db.rules().insertRule(RuleTesting.newRuleDto().setStatus(RuleStatus.BETA)).getDefinition();
+ RuleDefinitionDto betaRule2 = db.rules().insertRule(RuleTesting.newRuleDto().setStatus(RuleStatus.BETA)).getDefinition();
+ db.qualityProfiles().activateRule(profile1, rule1);
+ db.qualityProfiles().activateRule(profile2, betaRule1);
+ db.qualityProfiles().activateRule(profile2, betaRule2);
- Map<String, Long> counts = underTest.countActiveRulesForRuleStatusByProfileKey(dbSession, organization, RuleStatus.BETA);
+ Map<String, Long> counts = underTest.countActiveRulesForRuleStatusByProfileUuid(dbSession, organization, RuleStatus.BETA);
assertThat(counts).containsOnly(entry(profile2.getKee(), 2L));
}
@Test
public void countActiveRulesForRuleStatusByProfileKey_returns_empty_map_if_organization_does_not_exist() {
- Map<String, Long> counts = underTest.countActiveRulesForRuleStatusByProfileKey(dbSession, OrganizationTesting.newOrganizationDto(), RuleStatus.READY);
+ Map<String, Long> counts = underTest.countActiveRulesForRuleStatusByProfileUuid(dbSession, OrganizationTesting.newOrganizationDto(), RuleStatus.READY);
assertThat(counts).isEmpty();
}
@Test
public void countActiveRulesForRuleStatusByProfileKey_returns_empty_map_if_profile_does_not_have_rules_with_specified_status() {
- Map<String, Long> counts = underTest.countActiveRulesForRuleStatusByProfileKey(dbSession, organization, RuleStatus.DEPRECATED);
+ Map<String, Long> counts = underTest.countActiveRulesForRuleStatusByProfileUuid(dbSession, organization, RuleStatus.DEPRECATED);
assertThat(counts).isEmpty();
}
@Test
public void test_countActiveRulesForInheritanceByProfileKey_for_a_specified_organization() {
- dbTester.qualityProfiles().activateRule(profile1, rule1);
- dbTester.qualityProfiles().activateRule(profile2, rule1, ar -> ar.setInheritance(ActiveRuleDto.OVERRIDES));
- dbTester.qualityProfiles().activateRule(profile2, rule2, ar -> ar.setInheritance(ActiveRuleDto.INHERITED));
+ db.qualityProfiles().activateRule(profile1, rule1);
+ db.qualityProfiles().activateRule(profile2, rule1, ar -> ar.setInheritance(ActiveRuleDto.OVERRIDES));
+ db.qualityProfiles().activateRule(profile2, rule2, ar -> ar.setInheritance(ActiveRuleDto.INHERITED));
- Map<String, Long> counts = underTest.countActiveRulesForInheritanceByProfileKey(dbSession, organization, ActiveRuleDto.OVERRIDES);
+ Map<String, Long> counts = underTest.countActiveRulesForInheritanceByProfileUuid(dbSession, organization, ActiveRuleDto.OVERRIDES);
assertThat(counts).containsOnly(entry(profile2.getKee(), 1L));
}
@Test
public void countActiveRulesForInheritanceByProfileKey_returns_empty_map_if_organization_does_not_exist() {
- Map<String, Long> counts = underTest.countActiveRulesForInheritanceByProfileKey(dbSession, OrganizationTesting.newOrganizationDto(), ActiveRuleDto.OVERRIDES);
+ Map<String, Long> counts = underTest.countActiveRulesForInheritanceByProfileUuid(dbSession, OrganizationTesting.newOrganizationDto(), ActiveRuleDto.OVERRIDES);
assertThat(counts).isEmpty();
}
@Test
public void countActiveRulesForInheritanceByProfileKey_returns_empty_map_if_profile_does_not_have_rules_with_specified_status() {
- Map<String, Long> counts = underTest.countActiveRulesForInheritanceByProfileKey(dbSession, organization, ActiveRuleDto.OVERRIDES);
+ Map<String, Long> counts = underTest.countActiveRulesForInheritanceByProfileUuid(dbSession, organization, ActiveRuleDto.OVERRIDES);
assertThat(counts).isEmpty();
}
@Test
public void countActiveRulesForInheritanceByProfileKey_ignores_removed_rules() {
- dbTester.qualityProfiles().activateRule(profile1, rule1, ar -> ar.setInheritance(ActiveRuleDto.OVERRIDES));
- dbTester.qualityProfiles().activateRule(profile1, removedRule, ar -> ar.setInheritance(ActiveRuleDto.OVERRIDES));
+ db.qualityProfiles().activateRule(profile1, rule1, ar -> ar.setInheritance(ActiveRuleDto.OVERRIDES));
+ db.qualityProfiles().activateRule(profile1, removedRule, ar -> ar.setInheritance(ActiveRuleDto.OVERRIDES));
- Map<String, Long> counts = underTest.countActiveRulesForInheritanceByProfileKey(dbSession, organization, ActiveRuleDto.OVERRIDES);
+ Map<String, Long> counts = underTest.countActiveRulesForInheritanceByProfileUuid(dbSession, organization, ActiveRuleDto.OVERRIDES);
assertThat(counts).containsOnly(entry(profile1.getKee(), 1L));
}
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.fail;
+import static org.sonar.db.qualityprofile.QualityProfileTesting.newQualityProfileDto;
public class ActiveRuleKeyTest {
@Test
public void of() {
RuleKey ruleKey = RuleKey.of("xoo", "R1");
- ActiveRuleKey key = ActiveRuleKey.of("P1", ruleKey);
- assertThat(key.qProfile()).isEqualTo("P1");
- assertThat(key.ruleKey()).isSameAs(ruleKey);
- assertThat(key.toString()).isEqualTo("P1:xoo:R1");
+ QProfileDto profile = newQualityProfileDto();
+ ActiveRuleKey key = ActiveRuleKey.of(profile, ruleKey);
+ assertThat(key.getRuleProfileUuid()).isEqualTo(profile.getRulesProfileUuid());
+ assertThat(key.getRuleKey()).isSameAs(ruleKey);
+ assertThat(key.toString()).isEqualTo(profile.getRulesProfileUuid() + ":xoo:R1");
}
@Test
public void rule_key_can_contain_colons() {
RuleKey ruleKey = RuleKey.of("squid", "Key:With:Some::Colons");
- ActiveRuleKey key = ActiveRuleKey.of("P1", ruleKey);
- assertThat(key.qProfile()).isEqualTo("P1");
- assertThat(key.ruleKey()).isSameAs(ruleKey);
- assertThat(key.toString()).isEqualTo("P1:squid:Key:With:Some::Colons");
- }
-
- @Test
- public void profile_must_not_be_null() {
- try {
- ActiveRuleKey.of(null, RuleKey.of("xoo", "R1"));
- fail();
- } catch (NullPointerException e) {
- assertThat(e).hasMessage("QProfile is missing");
- }
- }
-
- @Test
- public void rule_key_must_not_be_null() {
- try {
- ActiveRuleKey.of("P1", null);
- fail();
- } catch (NullPointerException e) {
- assertThat(e).hasMessage("RuleKey is missing");
- }
+ QProfileDto profile = newQualityProfileDto();
+ ActiveRuleKey key = ActiveRuleKey.of(profile, ruleKey);
+ assertThat(key.getRuleProfileUuid()).isEqualTo(profile.getRulesProfileUuid());
+ assertThat(key.getRuleKey()).isSameAs(ruleKey);
+ assertThat(key.toString()).isEqualTo(profile.getRulesProfileUuid() + ":squid:Key:With:Some::Colons");
}
@Test
public void parse() {
ActiveRuleKey key = ActiveRuleKey.parse("P1:xoo:R1");
- assertThat(key.qProfile()).isEqualTo("P1");
- assertThat(key.ruleKey().repository()).isEqualTo("xoo");
- assertThat(key.ruleKey().rule()).isEqualTo("R1");
+ assertThat(key.getRuleProfileUuid()).isEqualTo("P1");
+ assertThat(key.getRuleKey().repository()).isEqualTo("xoo");
+ assertThat(key.getRuleKey().rule()).isEqualTo("R1");
}
@Test
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.sonar.api.utils.System2;
+import org.sonar.api.utils.internal.AlwaysIncreasingSystem2;
+import org.sonar.core.util.SequenceUuidFactory;
import org.sonar.core.util.UuidFactory;
import org.sonar.db.DbSession;
import org.sonar.db.DbTester;
import static java.util.Arrays.asList;
import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
public class QProfileChangeDaoTest {
- private static final long A_DATE = 1_500_000_000_000L;
-
- private System2 system2 = mock(System2.class);
+ private System2 system2 = new AlwaysIncreasingSystem2();
@Rule
public ExpectedException expectedException = ExpectedException.none();
-
@Rule
- public DbTester dbTester = DbTester.create(system2);
+ public DbTester db = DbTester.create(system2);
- private DbSession dbSession = dbTester.getSession();
- private UuidFactory uuidFactory = mock(UuidFactory.class);
+ private DbSession dbSession = db.getSession();
+ private UuidFactory uuidFactory = new SequenceUuidFactory();
private QProfileChangeDao underTest = new QProfileChangeDao(system2, uuidFactory);
@Test
- public void test_insert_without_null_fields() {
- when(system2.now()).thenReturn(A_DATE);
- when(uuidFactory.create()).thenReturn("C1");
-
- String profileKey = "P1";
- String login = "marcel";
- String type = "ACTIVATED";
- String data = "some_data";
- insertChange(profileKey, type, login, data);
+ public void insert() {
+ QProfileChangeDto dto = insertChange("P1", "ACTIVATED", "marcel", "some_data");
- Map<String, Object> row = selectChangeByKey("C1");
- assertThat(row.get("qprofileKey")).isEqualTo(profileKey);
- assertThat(row.get("createdAt")).isEqualTo(A_DATE);
- assertThat(row.get("login")).isEqualTo(login);
- assertThat(row.get("changeType")).isEqualTo(type);
- assertThat(row.get("changeData")).isEqualTo(data);
+ verifyInserted(dto);
}
/**
* user_login and data can be null
*/
@Test
- public void test_insert_with_nullable_fields() {
- when(system2.now()).thenReturn(A_DATE);
- when(uuidFactory.create()).thenReturn("C1");
+ public void test_insert_with_null_fields() {
+ QProfileChangeDto dto = insertChange("P1", "ACTIVATED", null, null);
- insertChange("P1", "ACTIVATED", null, null);
+ verifyInserted(dto);
+ }
- Map<String, Object> row = selectChangeByKey("C1");
- assertThat(row.get("qprofileKey")).isEqualTo("P1");
- assertThat(row.get("createdAt")).isEqualTo(A_DATE);
- assertThat(row.get("changeType")).isEqualTo("ACTIVATED");
- assertThat(row.get("login")).isNull();
- assertThat(row.get("changeData")).isNull();
+ private void verifyInserted(QProfileChangeDto dto) {
+ QProfileChangeDto reloaded = selectChangeByUuid(dto.getUuid());
+ assertThat(reloaded.getUuid()).isEqualTo(dto.getUuid());
+ assertThat(reloaded.getChangeType()).isEqualTo(dto.getChangeType());
+ assertThat(reloaded.getData()).isEqualTo(dto.getData());
+ assertThat(reloaded.getLogin()).isEqualTo(dto.getLogin());
+ assertThat(reloaded.getRulesProfileUuid()).isEqualTo(dto.getRulesProfileUuid());
+ assertThat(reloaded.getCreatedAt()).isPositive();
}
@Test
}
@Test
- public void selectByQuery_returns_empty_list_if_no_profile_changes() {
+ public void selectByQuery_returns_empty_list_if_profile_does_not_exist() {
List<QProfileChangeDto> changes = underTest.selectByQuery(dbSession, new QProfileChangeQuery("P1"));
+
assertThat(changes).isEmpty();
}
@Test
public void selectByQuery_returns_changes_ordered_by_descending_date() {
- when(system2.now()).thenReturn(A_DATE, A_DATE + 1, A_DATE + 2);
- when(uuidFactory.create()).thenReturn("C1", "C2", "C3");
+ QProfileDto profile1 = db.qualityProfiles().insert(db.getDefaultOrganization());
+ QProfileDto profile2 = db.qualityProfiles().insert(db.getDefaultOrganization());
- // profile P1
- insertChange("P1", "ACTIVATED", null, null);// key: C1
- insertChange("P1", "ACTIVATED", null, null);// key: C2
- // profile P2: C3
- insertChange("P2", "ACTIVATED", null, null);// key: C3
+ QProfileChangeDto change1OnP1 = insertChange(profile1, "ACTIVATED", null, null);
+ QProfileChangeDto change2OnP1 = insertChange(profile1, "ACTIVATED", null, null);
+ QProfileChangeDto changeOnP2 = insertChange(profile2, "ACTIVATED", null, null);
- List<QProfileChangeDto> changes = underTest.selectByQuery(dbSession, new QProfileChangeQuery("P1"));
- assertThat(changes).extracting(QProfileChangeDto::getKey).containsExactly("C2", "C1");
+ List<QProfileChangeDto> changes = underTest.selectByQuery(dbSession, new QProfileChangeQuery(profile1.getKee()));
+ assertThat(changes)
+ .extracting(QProfileChangeDto::getUuid)
+ .containsExactly(change2OnP1.getUuid(), change1OnP1.getUuid());
}
@Test
public void selectByQuery_supports_pagination_of_changes() {
- when(system2.now()).thenReturn(A_DATE, A_DATE + 10, A_DATE + 20, A_DATE + 30);
- when(uuidFactory.create()).thenReturn("C1", "C2", "C3", "C4");
- insertChange("P1", "ACTIVATED", null, null);// key: C1
- insertChange("P1", "ACTIVATED", null, null);// key: C2
- insertChange("P1", "ACTIVATED", null, null);// key: C3
- insertChange("P1", "ACTIVATED", null, null);// key: C4
-
- QProfileChangeQuery query = new QProfileChangeQuery("P1");
+ QProfileDto profile = db.qualityProfiles().insert(db.getDefaultOrganization());
+ QProfileChangeDto change1 = insertChange(profile, "ACTIVATED", null, null);
+ QProfileChangeDto change2 = insertChange(profile, "ACTIVATED", null, null);
+ QProfileChangeDto change3 = insertChange(profile, "ACTIVATED", null, null);
+ QProfileChangeDto change4 = insertChange(profile, "ACTIVATED", null, null);
+
+ QProfileChangeQuery query = new QProfileChangeQuery(profile.getKee());
query.setOffset(2);
query.setLimit(1);
List<QProfileChangeDto> changes = underTest.selectByQuery(dbSession, query);
- assertThat(changes).extracting(QProfileChangeDto::getKey).containsExactly("C2");
+ assertThat(changes)
+ .extracting(QProfileChangeDto::getUuid)
+ .containsExactly(change2.getUuid());
}
@Test
public void selectByQuery_returns_changes_after_given_date() {
- when(system2.now()).thenReturn(A_DATE, A_DATE + 10, A_DATE + 20);
- when(uuidFactory.create()).thenReturn("C1", "C2", "C3", "C4");
- insertChange("P1", "ACTIVATED", null, null);// key: C1
- insertChange("P1", "ACTIVATED", null, null);// key: C2
- insertChange("P1", "ACTIVATED", null, null);// key: C3
-
- QProfileChangeQuery query = new QProfileChangeQuery("P1");
- query.setFromIncluded(A_DATE + 10);
- List<QProfileChangeDto> changes = underTest.selectByQuery(dbSession, query);
- assertThat(changes).extracting(QProfileChangeDto::getKey).containsExactly("C3", "C2");
+ QProfileDto profile = db.qualityProfiles().insert(db.getDefaultOrganization());
+ QProfileChangeDto change1 = insertChange(profile, "ACTIVATED", null, null);
+ QProfileChangeDto change2 = insertChange(profile, "ACTIVATED", null, null);
+ QProfileChangeDto change3 = insertChange(profile, "ACTIVATED", null, null);
+
+ QProfileChangeQuery query = new QProfileChangeQuery(profile.getKee());
+ query.setFromIncluded(change1.getCreatedAt() + 1);
+
+ assertThat(underTest.selectByQuery(dbSession, query))
+ .extracting(QProfileChangeDto::getUuid)
+ .containsExactly(change3.getUuid(), change2.getUuid());
}
@Test
public void selectByQuery_returns_changes_before_given_date() {
- when(system2.now()).thenReturn(A_DATE, A_DATE + 10, A_DATE + 20);
- when(uuidFactory.create()).thenReturn("C1", "C2", "C3", "C4");
- insertChange("P1", "ACTIVATED", null, null);// key: C1
- insertChange("P1", "ACTIVATED", null, null);// key: C2
- insertChange("P1", "ACTIVATED", null, null);// key: C3
-
- QProfileChangeQuery query = new QProfileChangeQuery("P1");
- query.setToExcluded(A_DATE + 12);
- List<QProfileChangeDto> changes = underTest.selectByQuery(dbSession, query);
- assertThat(changes).extracting(QProfileChangeDto::getKey).containsExactly("C2", "C1");
+ QProfileDto profile = db.qualityProfiles().insert(db.getDefaultOrganization());
+ QProfileChangeDto change1 = insertChange(profile, "ACTIVATED", null, null);
+ QProfileChangeDto change2 = insertChange(profile, "ACTIVATED", null, null);
+ QProfileChangeDto change3 = insertChange(profile, "ACTIVATED", null, null);
+
+ QProfileChangeQuery query = new QProfileChangeQuery(profile.getKee());
+ query.setToExcluded(change2.getCreatedAt() + 1);
+
+ assertThat(underTest.selectByQuery(dbSession, query))
+ .extracting(QProfileChangeDto::getUuid)
+ .containsExactly(change2.getUuid(), change1.getUuid());
}
@Test
public void selectByQuery_returns_changes_in_a_range_of_dates() {
- when(system2.now()).thenReturn(A_DATE, A_DATE + 10, A_DATE + 20, A_DATE + 30);
- when(uuidFactory.create()).thenReturn("C1", "C2", "C3", "C4");
- insertChange("P1", "ACTIVATED", null, null);// key: C1
- insertChange("P1", "ACTIVATED", null, null);// key: C2
- insertChange("P1", "ACTIVATED", null, null);// key: C3
- insertChange("P1", "ACTIVATED", null, null);// key: C4
-
- QProfileChangeQuery query = new QProfileChangeQuery("P1");
- query.setFromIncluded(A_DATE + 8);
- query.setToExcluded(A_DATE + 22);
- List<QProfileChangeDto> changes = underTest.selectByQuery(dbSession, query);
- assertThat(changes).extracting(QProfileChangeDto::getKey).containsExactly("C3", "C2");
+ QProfileDto profile = db.qualityProfiles().insert(db.getDefaultOrganization());
+ QProfileChangeDto change1 = insertChange(profile, "ACTIVATED", null, null);
+ QProfileChangeDto change2 = insertChange(profile, "ACTIVATED", null, null);
+ QProfileChangeDto change3 = insertChange(profile, "ACTIVATED", null, null);
+ QProfileChangeDto change4 = insertChange(profile, "ACTIVATED", null, null);
+
+ QProfileChangeQuery query = new QProfileChangeQuery(profile.getKee());
+ query.setFromIncluded(change1.getCreatedAt() + 1);
+ query.setToExcluded(change4.getCreatedAt());
+
+ assertThat(underTest.selectByQuery(dbSession, query))
+ .extracting(QProfileChangeDto::getUuid)
+ .containsExactly(change3.getUuid(), change2.getUuid());
}
@Test
- public void selectByQuery_mapping() {
- when(system2.now()).thenReturn(A_DATE);
- when(uuidFactory.create()).thenReturn("C1");
- insertChange("P1", "ACTIVATED", "Oscar", "data");
+ public void test_selectByQuery_mapping() {
+ QProfileDto profile = db.qualityProfiles().insert(db.getDefaultOrganization());
+ QProfileChangeDto inserted = insertChange(profile, "ACTIVATED", "theLogin", "theData");
- List<QProfileChangeDto> result = underTest.selectByQuery(dbSession, new QProfileChangeQuery("P1"));
+ List<QProfileChangeDto> result = underTest.selectByQuery(dbSession, new QProfileChangeQuery(profile.getKee()));
assertThat(result).hasSize(1);
QProfileChangeDto change = result.get(0);
- assertThat(change.getProfileKey()).isEqualTo("P1");
- assertThat(change.getLogin()).isEqualTo("Oscar");
- assertThat(change.getData()).isEqualTo("data");
- assertThat(change.getChangeType()).isEqualTo("ACTIVATED");
- assertThat(change.getKey()).isEqualTo("C1");
- assertThat(change.getCreatedAt()).isEqualTo(A_DATE);
+ assertThat(change.getRulesProfileUuid()).isEqualTo(inserted.getRulesProfileUuid());
+ assertThat(change.getLogin()).isEqualTo(inserted.getLogin());
+ assertThat(change.getData()).isEqualTo(inserted.getData());
+ assertThat(change.getChangeType()).isEqualTo(inserted.getChangeType());
+ assertThat(change.getUuid()).isEqualTo(inserted.getUuid());
+ assertThat(change.getCreatedAt()).isEqualTo(inserted.getCreatedAt());
}
@Test
- public void test_countForProfileKey() {
- when(system2.now()).thenReturn(A_DATE, A_DATE + 10);
- when(uuidFactory.create()).thenReturn("C1", "C2");
-
- insertChange("P1", "ACTIVATED", null, null);// key: C1
- insertChange("P1", "ACTIVATED", null, null);// key: C2
-
- assertThat(underTest.countForProfileUuid(dbSession, "P1")).isEqualTo(2);
- assertThat(underTest.countForProfileUuid(dbSession, "P2")).isEqualTo(0);
+ public void countForQProfileUuid() {
+ QProfileDto profile1 = db.qualityProfiles().insert(db.getDefaultOrganization());
+ QProfileDto profile2 = db.qualityProfiles().insert(db.getDefaultOrganization());
+ insertChange(profile1, "ACTIVATED", null, null);
+ insertChange(profile1, "ACTIVATED", null, null);
+ insertChange(profile2, "ACTIVATED", null, null);
+
+ assertThat(underTest.countForQProfileUuid(dbSession, profile1.getKee())).isEqualTo(2);
+ assertThat(underTest.countForQProfileUuid(dbSession, profile2.getKee())).isEqualTo(1);
+ assertThat(underTest.countForQProfileUuid(dbSession, "does_not_exist")).isEqualTo(0);
}
@Test
- public void deleteByProfileKeys_deletes_rows_with_specified_keys() {
- when(uuidFactory.create()).thenReturn("C1", "C2", "C3");
- insertChange("P1", "ACTIVATED", null, null);// key: C1
- insertChange("P1", "ACTIVATED", null, null);// key: C2
- insertChange("P2", "ACTIVATED", null, null);// key: C3
+ public void deleteByRulesProfileUuids() {
+ QProfileDto profile1 = db.qualityProfiles().insert(db.getDefaultOrganization());
+ QProfileDto profile2 = db.qualityProfiles().insert(db.getDefaultOrganization());
+ insertChange(profile1, "ACTIVATED", null, null);
+ insertChange(profile1, "ACTIVATED", null, null);
+ insertChange(profile2, "ACTIVATED", null, null);
- underTest.deleteByProfileKeys(dbSession, asList("P1"));
+ underTest.deleteByRulesProfileUuids(dbSession, asList(profile1.getRulesProfileUuid()));
- assertThat(underTest.countForProfileUuid(dbSession, "P1")).isEqualTo(0);
- assertThat(underTest.countForProfileUuid(dbSession, "P2")).isEqualTo(1);
+ assertThat(underTest.countForQProfileUuid(dbSession, profile1.getKee())).isEqualTo(0);
+ assertThat(underTest.countForQProfileUuid(dbSession, profile2.getKee())).isEqualTo(1);
}
@Test
public void deleteByProfileKeys_does_nothing_if_row_with_specified_key_does_not_exist() {
- when(uuidFactory.create()).thenReturn("C1");
- insertChange("P1", "ACTIVATED", null, null);
+ QProfileDto profile1 = db.qualityProfiles().insert(db.getDefaultOrganization());
+ insertChange(profile1.getRulesProfileUuid(), "ACTIVATED", null, null);
- underTest.deleteByProfileKeys(dbSession, asList("does_not_exist"));
+ underTest.deleteByRulesProfileUuids(dbSession, asList("does not exist"));
+
+ assertThat(underTest.countForQProfileUuid(dbSession, profile1.getKee())).isEqualTo(1);
+ }
- assertThat(underTest.countForProfileUuid(dbSession, "P1")).isEqualTo(1);
+ private QProfileChangeDto insertChange(QProfileDto profile, String type, @Nullable String login, @Nullable String data) {
+ return insertChange(profile.getRulesProfileUuid(), type, login, data);
}
- private void insertChange(String profileKey, String type, @Nullable String login, @Nullable String data) {
+ private QProfileChangeDto insertChange(String rulesProfileUuid, String type, @Nullable String login, @Nullable String data) {
QProfileChangeDto dto = new QProfileChangeDto()
- .setProfileKey(profileKey)
+ .setRulesProfileUuid(rulesProfileUuid)
.setLogin(login)
.setChangeType(type)
.setData(data);
underTest.insert(dbSession, dto);
+ return dto;
}
- private Map<String, Object> selectChangeByKey(String key) {
- return dbTester.selectFirst(dbSession,
- "select qprofile_key as \"qprofileKey\", created_at as \"createdAt\", user_login as \"login\", change_type as \"changeType\", change_data as \"changeData\" from qprofile_changes where kee='"
- + key + "'");
+ private QProfileChangeDto selectChangeByUuid(String uuid) {
+ Map<String, Object> map = db.selectFirst(dbSession,
+ "select kee as \"uuid\", qprofile_key as \"rulesProfileUuid\", created_at as \"createdAt\", user_login as \"login\", change_type as \"changeType\", change_data as \"changeData\" from qprofile_changes where kee='"
+ + uuid + "'");
+ return new QProfileChangeDto()
+ .setUuid((String) map.get("uuid"))
+ .setRulesProfileUuid((String) map.get("rulesProfileUuid"))
+ .setCreatedAt((long) map.get("createdAt"))
+ .setLogin((String) map.get("login"))
+ .setChangeType((String) map.get("changeType"))
+ .setData((String) map.get("changeData"));
}
}
import org.junit.Test;
import org.sonar.api.utils.System2;
import org.sonar.core.util.UtcDateUtils;
+import org.sonar.core.util.Uuids;
import org.sonar.db.DbSession;
import org.sonar.db.DbTester;
import org.sonar.db.component.ComponentDto;
import static java.util.Arrays.asList;
import static java.util.Collections.emptyList;
import static java.util.Collections.singletonList;
+import static org.apache.commons.lang.RandomStringUtils.randomAlphanumeric;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.tuple;
import static org.mockito.Mockito.mock;
private System2 system = mock(System2.class);
@Rule
- public DbTester dbTester = DbTester.create(system);
+ public DbTester db = DbTester.create(system);
- private DbSession dbSession = dbTester.getSession();
- private QualityProfileDao underTest = dbTester.getDbClient().qualityProfileDao();
+ private DbSession dbSession = db.getSession();
+ private QualityProfileDao underTest = db.getDbClient().qualityProfileDao();
private OrganizationDto organization;
@Before
public void before() {
when(system.now()).thenReturn(UtcDateUtils.parseDateTime("2014-01-20T12:00:00+0000").getTime());
- organization = dbTester.organizations().insertForUuid("QualityProfileDaoTest-ORG");
+ organization = db.organizations().insertForUuid("QualityProfileDaoTest-ORG");
}
@After
@Test
public void test_insert() {
- QProfileDto dto = QProfileDto.createFor("theUuid")
+ QProfileDto dto = new QProfileDto()
+ .setKee("theUuid")
+ .setRulesProfileUuid("theRulesProfileUuid")
.setOrganizationUuid(organization.getUuid())
.setName("theName")
.setLanguage("theLang")
QProfileDto reloaded = underTest.selectByUuid(dbSession, dto.getKee());
assertThat(reloaded.getKee()).isEqualTo(dto.getKee());
+ assertThat(reloaded.getRulesProfileUuid()).isEqualTo(dto.getRulesProfileUuid());
assertThat(reloaded.getId()).isNotNull().isNotZero();
assertThat(reloaded.getLanguage()).isEqualTo(dto.getLanguage());
assertThat(reloaded.getName()).isEqualTo(dto.getName());
@Test
public void test_update() {
- QProfileDto initial = QProfileDto.createFor("theUuid")
+ QProfileDto initial = new QProfileDto()
+ .setKee("theUuid")
+ .setRulesProfileUuid("theRulesProfileUuid")
.setOrganizationUuid(organization.getUuid())
.setName("theName")
.setLanguage("theLang")
.setIsBuiltIn(true);
underTest.insert(dbSession, initial);
- QProfileDto update = QProfileDto.createFor(initial.getKee())
+ QProfileDto update = new QProfileDto()
+ .setKee(initial.getKee())
+ .setRulesProfileUuid(initial.getRulesProfileUuid())
.setName("theNewName")
.setLanguage("theNewLang")
.setLastUsed(11_000L)
}
@Test
- public void test_deleteByUuids() {
- QProfileDto p1 = dbTester.qualityProfiles().insert(organization);
- QProfileDto p2 = dbTester.qualityProfiles().insert(organization);
- QProfileDto p3 = dbTester.qualityProfiles().insert(organization);
+ public void deleteRulesProfilesByUuids() {
+ RulesProfileDto rp1 = insertRulesProfile();
+ RulesProfileDto rp2 = insertRulesProfile();
- underTest.deleteByUuids(dbSession, asList(p1.getKee(), p3.getKee(), "does_not_exist"));
+ underTest.deleteRulesProfilesByUuids(dbSession, asList(rp1.getKee()));
- List<QProfileDto> profiles = underTest.selectAll(dbSession, organization);
- assertThat(profiles).extracting(QProfileDto::getKee).containsExactly(p2.getKee());
+ List<Map<String, Object>> uuids = db.select(dbSession, "select kee as \"uuid\" from rules_profiles");
+ assertThat(uuids).hasSize(1);
+ assertThat(uuids.get(0).get("uuid")).isEqualTo(rp2.getKee());
}
@Test
- public void deleteByUuids_does_nothing_if_empty_uuids() {
- dbTester.qualityProfiles().insert(organization);
+ public void deleteRulesProfilesByUuids_does_nothing_if_empty_input() {
+ insertRulesProfile();
- underTest.deleteByUuids(dbSession, Collections.emptyList());
+ underTest.deleteRulesProfilesByUuids(dbSession, emptyList());
- assertThat(dbTester.countRowsOfTable(dbSession, "rules_profiles")).isEqualTo(1);
- assertThat(dbTester.countRowsOfTable(dbSession, "org_qprofiles")).isEqualTo(1);
+ assertThat(db.countRowsOfTable(dbSession, "rules_profiles")).isEqualTo(1);
+ }
+
+ @Test
+ public void deleteRulesProfilesByUuids_does_nothing_if_specified_uuid_does_not_exist() {
+ insertRulesProfile();
+
+ underTest.deleteRulesProfilesByUuids(dbSession, asList("does_not_exist"));
+
+ assertThat(db.countRowsOfTable(dbSession, "rules_profiles")).isEqualTo(1);
+ }
+
+ private RulesProfileDto insertRulesProfile() {
+ RulesProfileDto dto = new RulesProfileDto()
+ .setName(randomAlphanumeric(10))
+ .setLanguage(randomAlphanumeric(3))
+ .setKee(Uuids.createFast())
+ .setIsBuiltIn(false);
+ db.getDbClient().qualityProfileDao().insert(dbSession, dto);
+ return dto;
}
@Test
public void test_deleteProjectAssociationsByProfileUuids() {
- QProfileDto profile1 = dbTester.qualityProfiles().insert(organization);
- QProfileDto profile2 = dbTester.qualityProfiles().insert(organization);
- ComponentDto project1 = dbTester.components().insertPrivateProject(organization);
- ComponentDto project2 = dbTester.components().insertPrivateProject(organization);
- ComponentDto project3 = dbTester.components().insertPrivateProject(organization);
- dbTester.qualityProfiles().associateWithProject(project1, profile1);
- dbTester.qualityProfiles().associateWithProject(project2, profile1);
- dbTester.qualityProfiles().associateWithProject(project3, profile2);
+ QProfileDto profile1 = db.qualityProfiles().insert(organization);
+ QProfileDto profile2 = db.qualityProfiles().insert(organization);
+ ComponentDto project1 = db.components().insertPrivateProject(organization);
+ ComponentDto project2 = db.components().insertPrivateProject(organization);
+ ComponentDto project3 = db.components().insertPrivateProject(organization);
+ db.qualityProfiles().associateWithProject(project1, profile1);
+ db.qualityProfiles().associateWithProject(project2, profile1);
+ db.qualityProfiles().associateWithProject(project3, profile2);
underTest.deleteProjectAssociationsByProfileUuids(dbSession, asList(profile1.getKee(), "does_not_exist"));
- List<Map<String, Object>> rows = dbTester.select(dbSession, "select project_uuid as \"projectUuid\", profile_key as \"profileKey\" from project_qprofiles");
+ List<Map<String, Object>> rows = db.select(dbSession, "select project_uuid as \"projectUuid\", profile_key as \"profileKey\" from project_qprofiles");
assertThat(rows).hasSize(1);
assertThat(rows.get(0).get("projectUuid")).isEqualTo(project3.uuid());
assertThat(rows.get(0).get("profileKey")).isEqualTo(profile2.getKee());
@Test
public void deleteProjectAssociationsByProfileUuids_does_nothing_if_empty_uuids() {
- QProfileDto profile = dbTester.qualityProfiles().insert(organization);
- ComponentDto project = dbTester.components().insertPrivateProject();
- dbTester.qualityProfiles().associateWithProject(project, profile);
+ QProfileDto profile = db.qualityProfiles().insert(organization);
+ ComponentDto project = db.components().insertPrivateProject();
+ db.qualityProfiles().associateWithProject(project, profile);
underTest.deleteProjectAssociationsByProfileUuids(dbSession, Collections.emptyList());
- assertThat(dbTester.countRowsOfTable(dbSession, "project_qprofiles")).isEqualTo(1);
+ assertThat(db.countRowsOfTable(dbSession, "project_qprofiles")).isEqualTo(1);
}
@Test
public void test_selectAll() {
List<QProfileDto> sharedData = createSharedData();
- List<QProfileDto> reloadeds = underTest.selectAll(dbSession, organization);
+ List<QProfileDto> reloadeds = underTest.selectOrderedByOrganizationUuid(dbSession, organization);
assertThat(reloadeds).hasSize(sharedData.size());
assertThat(reloaded.getLastUsed()).isEqualTo(original.getLastUsed());
assertThat(reloaded.getUserUpdatedAt()).isEqualTo(original.getUserUpdatedAt());
assertThat(reloaded.isBuiltIn()).isEqualTo(original.isBuiltIn());
- }
- );
+ });
}
@Test
public void find_all_is_sorted_by_profile_name() {
- QProfileDto dto1 = QProfileDto.createFor("js_first")
+ QProfileDto dto1 = new QProfileDto()
+ .setKee("js_first")
+ .setRulesProfileUuid("rp-js_first")
.setOrganizationUuid(organization.getUuid())
.setName("First")
.setLanguage("js")
.setIsBuiltIn(false);
underTest.insert(dbSession, dto1);
- QProfileDto dto2 = QProfileDto.createFor("js_second")
+ QProfileDto dto2 = new QProfileDto()
+ .setKee("js_second")
+ .setRulesProfileUuid("rp-js_second")
.setOrganizationUuid(organization.getUuid())
.setName("Second")
.setLanguage("js")
.setIsBuiltIn(false);
underTest.insert(dbSession, dto2);
- QProfileDto dto3 = QProfileDto.createFor("js_third")
+ QProfileDto dto3 = new QProfileDto()
+ .setKee("js_third")
+ .setRulesProfileUuid("rp-js_third")
.setOrganizationUuid(organization.getUuid())
.setName("Third")
.setLanguage("js")
.setIsBuiltIn(false);
underTest.insert(dbSession, dto3);
- List<QProfileDto> dtos = underTest.selectAll(dbSession, organization);
+ List<QProfileDto> dtos = underTest.selectOrderedByOrganizationUuid(dbSession, organization);
assertThat(dtos).hasSize(3);
assertThat(dtos.get(0).getName()).isEqualTo("First");
assertThat(dtos.get(1).getName()).isEqualTo("Second");
assertThat(dtos.get(2).getName()).isEqualTo("Third");
-
- underTest.deleteByUuids(dbSession, Arrays.asList("js_first", "js_second", "js_third"));
}
@Test
- public void get_default_profile() {
+ public void selectDefaultProfile() {
List<QProfileDto> sharedData = createSharedData();
QProfileDto java = underTest.selectDefaultProfile(dbSession, organization, "java");
assertThat(java).isNotNull();
assertThat(java.getKee()).isEqualTo("java_sonar_way");
- assertThat(underTest.selectDefaultProfile(dbSession, dbTester.organizations().insert(), "java")).isNull();
+ assertThat(underTest.selectDefaultProfile(dbSession, db.organizations().insert(), "java")).isNull();
assertThat(underTest.selectDefaultProfile(dbSession, organization, "js")).isNull();
}
@Test
- public void get_default_profiles() {
+ public void selectDefaultProfiles() {
List<QProfileDto> sharedData = createSharedData();
List<QProfileDto> java = underTest.selectDefaultProfiles(dbSession, organization, singletonList("java"));
}
@Test
- public void should_find_by_language() {
+ public void selectByLanguage() {
QProfileDto profile = QualityProfileTesting.newQualityProfileDto()
.setOrganizationUuid(organization.getUuid());
underTest.insert(dbSession, profile);
assertThat(result.getKee()).isEqualTo(profile.getKee());
assertThat(result.getLanguage()).isEqualTo(profile.getLanguage());
assertThat(result.getOrganizationUuid()).isEqualTo(profile.getOrganizationUuid());
+ assertThat(result.getRulesProfileUuid()).isEqualTo(profile.getRulesProfileUuid());
}
@Test
assertThat(results).isEmpty();
}
-
@Test
public void find_children() {
- QProfileDto original1 = QProfileDto.createFor("java_child1")
+ QProfileDto original1 = new QProfileDto()
+ .setKee("java_child1")
+ .setRulesProfileUuid("rp-java_child1")
.setOrganizationUuid(organization.getUuid())
.setName("Child1")
.setLanguage("java")
.setIsBuiltIn(false);
underTest.insert(dbSession, original1);
- QProfileDto original2 = QProfileDto.createFor("java_child2")
+ QProfileDto original2 = new QProfileDto()
+ .setKee("java_child2")
+ .setRulesProfileUuid("rp-java_child2")
.setOrganizationUuid(organization.getUuid())
.setName("Child2")
.setLanguage("java")
.setIsBuiltIn(false);
underTest.insert(dbSession, original2);
- QProfileDto original3 = QProfileDto.createFor("java_parent")
+ QProfileDto original3 = new QProfileDto()
+ .setKee("java_parent")
+ .setRulesProfileUuid("rp-java_parent")
.setOrganizationUuid(organization.getUuid())
.setName("Parent")
.setLanguage("java")
.setIsBuiltIn(false);
underTest.insert(dbSession, original3);
- QProfileDto original4 = QProfileDto.createFor("js_child1")
+ QProfileDto original4 = new QProfileDto()
+ .setKee("js_child1")
+ .setRulesProfileUuid("rp-js_child1")
.setOrganizationUuid(organization.getUuid())
.setName("Child1")
.setLanguage("js")
.setIsBuiltIn(false);
underTest.insert(dbSession, original4);
- QProfileDto original5 = QProfileDto.createFor("js_child2")
+ QProfileDto original5 = new QProfileDto()
+ .setKee("js_child2")
+ .setRulesProfileUuid("rp-js_child2")
.setOrganizationUuid(organization.getUuid())
.setName("Child2")
.setLanguage("js")
.setIsBuiltIn(false);
underTest.insert(dbSession, original5);
- QProfileDto original6 = QProfileDto.createFor("js_parent")
+ QProfileDto original6 = new QProfileDto()
+ .setKee("js_parent")
+ .setRulesProfileUuid("rp-js_parent")
.setOrganizationUuid(organization.getUuid())
.setName("Parent")
.setLanguage("js")
.setIsBuiltIn(false);
underTest.insert(dbSession, original6);
- List<QProfileDto> dtos = underTest.selectChildren(dbSession, "java_parent");
+ List<QProfileDto> dtos = underTest.selectChildren(dbSession, original3);
assertThat(dtos).hasSize(2);
assertThat(dto2.getName()).isEqualTo("Child2");
assertThat(dto2.getLanguage()).isEqualTo("java");
assertThat(dto2.getParentKee()).isEqualTo("java_parent");
-
- underTest.deleteByUuids(dbSession, Arrays.asList("java_parent", "java_child1", "java_child2", "js_parent", "js_child1", "js_child2"));
}
@Test
public void countProjectsByProfileKey() {
- QProfileDto profileWithoutProjects = dbTester.qualityProfiles().insert(organization);
- QProfileDto profileWithProjects = dbTester.qualityProfiles().insert(organization);
- ComponentDto project1 = dbTester.components().insertPrivateProject(organization);
- ComponentDto project2 = dbTester.components().insertPrivateProject(organization);
- dbTester.qualityProfiles().associateWithProject(project1, profileWithProjects);
- dbTester.qualityProfiles().associateWithProject(project2, profileWithProjects);
-
- OrganizationDto otherOrg = dbTester.organizations().insert();
- QProfileDto profileInOtherOrg = dbTester.qualityProfiles().insert(otherOrg);
- ComponentDto projectInOtherOrg = dbTester.components().insertPrivateProject(otherOrg);
- dbTester.qualityProfiles().associateWithProject(projectInOtherOrg, profileInOtherOrg);
+ QProfileDto profileWithoutProjects = db.qualityProfiles().insert(organization);
+ QProfileDto profileWithProjects = db.qualityProfiles().insert(organization);
+ ComponentDto project1 = db.components().insertPrivateProject(organization);
+ ComponentDto project2 = db.components().insertPrivateProject(organization);
+ db.qualityProfiles().associateWithProject(project1, profileWithProjects);
+ db.qualityProfiles().associateWithProject(project2, profileWithProjects);
+
+ OrganizationDto otherOrg = db.organizations().insert();
+ QProfileDto profileInOtherOrg = db.qualityProfiles().insert(otherOrg);
+ ComponentDto projectInOtherOrg = db.components().insertPrivateProject(otherOrg);
+ db.qualityProfiles().associateWithProject(projectInOtherOrg, profileInOtherOrg);
assertThat(underTest.countProjectsByProfileUuid(dbSession, organization)).containsOnly(
MapEntry.entry(profileWithProjects.getKee(), 2L));
@Test
public void test_selectAssociatedToProjectAndLanguage() {
- OrganizationDto org = dbTester.organizations().insert();
- ComponentDto project1 = dbTester.components().insertPublicProject(org);
- ComponentDto project2 = dbTester.components().insertPublicProject(org);
- QProfileDto javaProfile = dbTester.qualityProfiles().insert(org, p -> p.setLanguage("java"));
- QProfileDto jsProfile = dbTester.qualityProfiles().insert(org, p -> p.setLanguage("js"));
- dbTester.qualityProfiles().associateWithProject(project1, javaProfile, jsProfile);
+ OrganizationDto org = db.organizations().insert();
+ ComponentDto project1 = db.components().insertPublicProject(org);
+ ComponentDto project2 = db.components().insertPublicProject(org);
+ QProfileDto javaProfile = db.qualityProfiles().insert(org, p -> p.setLanguage("java"));
+ QProfileDto jsProfile = db.qualityProfiles().insert(org, p -> p.setLanguage("js"));
+ db.qualityProfiles().associateWithProject(project1, javaProfile, jsProfile);
assertThat(underTest.selectAssociatedToProjectAndLanguage(dbSession, project1, "java").getKee())
.isEqualTo(javaProfile.getKee());
@Test
public void test_selectAssociatedToProjectUuidAndLanguages() {
- OrganizationDto org = dbTester.organizations().insert();
- ComponentDto project1 = dbTester.components().insertPublicProject(org);
- ComponentDto project2 = dbTester.components().insertPublicProject(org);
- QProfileDto javaProfile = dbTester.qualityProfiles().insert(org, p -> p.setLanguage("java"));
- QProfileDto jsProfile = dbTester.qualityProfiles().insert(org, p -> p.setLanguage("js"));
- dbTester.qualityProfiles().associateWithProject(project1, javaProfile, jsProfile);
+ OrganizationDto org = db.organizations().insert();
+ ComponentDto project1 = db.components().insertPublicProject(org);
+ ComponentDto project2 = db.components().insertPublicProject(org);
+ QProfileDto javaProfile = db.qualityProfiles().insert(org, p -> p.setLanguage("java"));
+ QProfileDto jsProfile = db.qualityProfiles().insert(org, p -> p.setLanguage("js"));
+ db.qualityProfiles().associateWithProject(project1, javaProfile, jsProfile);
assertThat(underTest.selectAssociatedToProjectUuidAndLanguages(dbSession, project1, singletonList("java")))
.extracting(QProfileDto::getKee).containsOnly(javaProfile.getKee());
@Test
public void test_updateProjectProfileAssociation() {
- OrganizationDto org = dbTester.organizations().insert();
- ComponentDto project = dbTester.components().insertPrivateProject(org);
- QProfileDto javaProfile1 = dbTester.qualityProfiles().insert(org, p -> p.setLanguage("java"));
- QProfileDto jsProfile = dbTester.qualityProfiles().insert(org, p -> p.setLanguage("js"));
- QProfileDto javaProfile2 = dbTester.qualityProfiles().insert(org, p -> p.setLanguage("java"));
- dbTester.qualityProfiles().associateWithProject(project, javaProfile1, jsProfile);
+ OrganizationDto org = db.organizations().insert();
+ ComponentDto project = db.components().insertPrivateProject(org);
+ QProfileDto javaProfile1 = db.qualityProfiles().insert(org, p -> p.setLanguage("java"));
+ QProfileDto jsProfile = db.qualityProfiles().insert(org, p -> p.setLanguage("js"));
+ QProfileDto javaProfile2 = db.qualityProfiles().insert(org, p -> p.setLanguage("java"));
+ db.qualityProfiles().associateWithProject(project, javaProfile1, jsProfile);
underTest.updateProjectProfileAssociation(dbSession, project, javaProfile2.getKee(), javaProfile1.getKee());
@Test
public void selectByKeys() {
- dbTester.qualityProfiles().insert(newQualityProfileDto().setKey("qp-key-1"), newQualityProfileDto().setKee("qp-key-2"), newQualityProfileDto().setKee("qp-key-3"));
+ db.qualityProfiles().insert(newQualityProfileDto().setKee("qp-key-1"), newQualityProfileDto().setKee("qp-key-2"), newQualityProfileDto().setKee("qp-key-3"));
assertThat(underTest.selectOrFailByUuid(dbSession, "qp-key-1")).isNotNull();
assertThat(underTest.selectByUuid(dbSession, "qp-key-1")).isNotNull();
@Test
public void select_selected_projects() throws Exception {
- ComponentDto project1 = dbTester.components().insertPrivateProject(t -> t.setName("Project1 name"), t -> t.setOrganizationUuid(organization.getUuid()));
- ComponentDto project2 = dbTester.components().insertPrivateProject(t -> t.setName("Project2 name"), t -> t.setOrganizationUuid(organization.getUuid()));
- ComponentDto project3 = dbTester.components().insertPrivateProject(t -> t.setName("Project3 name"), t -> t.setOrganizationUuid(organization.getUuid()));
- OrganizationDto organization2 = dbTester.organizations().insert();
- ComponentDto project4 = dbTester.components().insertPrivateProject(t -> t.setName("Project4 name"), t -> t.setOrganizationUuid(organization2.getUuid()));
+ ComponentDto project1 = db.components().insertPrivateProject(t -> t.setName("Project1 name"), t -> t.setOrganizationUuid(organization.getUuid()));
+ ComponentDto project2 = db.components().insertPrivateProject(t -> t.setName("Project2 name"), t -> t.setOrganizationUuid(organization.getUuid()));
+ ComponentDto project3 = db.components().insertPrivateProject(t -> t.setName("Project3 name"), t -> t.setOrganizationUuid(organization.getUuid()));
+ OrganizationDto organization2 = db.organizations().insert();
+ ComponentDto project4 = db.components().insertPrivateProject(t -> t.setName("Project4 name"), t -> t.setOrganizationUuid(organization2.getUuid()));
QProfileDto profile1 = newQualityProfileDto();
- dbTester.qualityProfiles().insert(profile1);
- dbTester.qualityProfiles().associateWithProject(project1, profile1);
- dbTester.qualityProfiles().associateWithProject(project2, profile1);
+ db.qualityProfiles().insert(profile1);
+ db.qualityProfiles().associateWithProject(project1, profile1);
+ db.qualityProfiles().associateWithProject(project2, profile1);
QProfileDto profile2 = newQualityProfileDto();
- dbTester.qualityProfiles().insert(profile2);
- dbTester.qualityProfiles().associateWithProject(project3, profile2);
+ db.qualityProfiles().insert(profile2);
+ db.qualityProfiles().associateWithProject(project3, profile2);
QProfileDto profile3 = newQualityProfileDto();
assertThat(underTest.selectSelectedProjects(dbSession, organization, profile1, null))
@Test
public void select_deselected_projects() throws Exception {
- ComponentDto project1 = dbTester.components().insertPrivateProject(t -> t.setName("Project1 name"), t -> t.setOrganizationUuid(organization.getUuid()));
- ComponentDto project2 = dbTester.components().insertPrivateProject(t -> t.setName("Project2 name"), t -> t.setOrganizationUuid(organization.getUuid()));
- ComponentDto project3 = dbTester.components().insertPrivateProject(t -> t.setName("Project3 name"), t -> t.setOrganizationUuid(organization.getUuid()));
- OrganizationDto organization2 = dbTester.organizations().insert();
- ComponentDto project4 = dbTester.components().insertPrivateProject(t -> t.setName("Project4 name"), t -> t.setOrganizationUuid(organization2.getUuid()));
+ ComponentDto project1 = db.components().insertPrivateProject(t -> t.setName("Project1 name"), t -> t.setOrganizationUuid(organization.getUuid()));
+ ComponentDto project2 = db.components().insertPrivateProject(t -> t.setName("Project2 name"), t -> t.setOrganizationUuid(organization.getUuid()));
+ ComponentDto project3 = db.components().insertPrivateProject(t -> t.setName("Project3 name"), t -> t.setOrganizationUuid(organization.getUuid()));
+ OrganizationDto organization2 = db.organizations().insert();
+ ComponentDto project4 = db.components().insertPrivateProject(t -> t.setName("Project4 name"), t -> t.setOrganizationUuid(organization2.getUuid()));
QProfileDto profile1 = newQualityProfileDto();
- dbTester.qualityProfiles().insert(profile1);
- dbTester.qualityProfiles().associateWithProject(project1, profile1);
+ db.qualityProfiles().insert(profile1);
+ db.qualityProfiles().associateWithProject(project1, profile1);
QProfileDto profile2 = newQualityProfileDto();
- dbTester.qualityProfiles().insert(profile2);
- dbTester.qualityProfiles().associateWithProject(project2, profile2);
+ db.qualityProfiles().insert(profile2);
+ db.qualityProfiles().associateWithProject(project2, profile2);
QProfileDto profile3 = newQualityProfileDto();
assertThat(underTest.selectDeselectedProjects(dbSession, organization, profile1, null))
@Test
public void select_project_associations() throws Exception {
- ComponentDto project1 = dbTester.components().insertPrivateProject(t -> t.setName("Project1 name"), t -> t.setOrganizationUuid(organization.getUuid()));
- ComponentDto project2 = dbTester.components().insertPrivateProject(t -> t.setName("Project2 name"), t -> t.setOrganizationUuid(organization.getUuid()));
- ComponentDto project3 = dbTester.components().insertPrivateProject(t -> t.setName("Project3 name"), t -> t.setOrganizationUuid(organization.getUuid()));
- OrganizationDto organization2 = dbTester.organizations().insert();
- ComponentDto project4 = dbTester.components().insertPrivateProject(t -> t.setName("Project4 name"), t -> t.setOrganizationUuid(organization2.getUuid()));
+ ComponentDto project1 = db.components().insertPrivateProject(t -> t.setName("Project1 name"), t -> t.setOrganizationUuid(organization.getUuid()));
+ ComponentDto project2 = db.components().insertPrivateProject(t -> t.setName("Project2 name"), t -> t.setOrganizationUuid(organization.getUuid()));
+ ComponentDto project3 = db.components().insertPrivateProject(t -> t.setName("Project3 name"), t -> t.setOrganizationUuid(organization.getUuid()));
+ OrganizationDto organization2 = db.organizations().insert();
+ ComponentDto project4 = db.components().insertPrivateProject(t -> t.setName("Project4 name"), t -> t.setOrganizationUuid(organization2.getUuid()));
QProfileDto profile1 = newQualityProfileDto();
- dbTester.qualityProfiles().insert(profile1);
- dbTester.qualityProfiles().associateWithProject(project1, profile1);
+ db.qualityProfiles().insert(profile1);
+ db.qualityProfiles().associateWithProject(project1, profile1);
QProfileDto profile2 = newQualityProfileDto();
- dbTester.qualityProfiles().insert(profile2);
- dbTester.qualityProfiles().associateWithProject(project2, profile2);
+ db.qualityProfiles().insert(profile2);
+ db.qualityProfiles().associateWithProject(project2, profile2);
QProfileDto profile3 = newQualityProfileDto();
assertThat(underTest.selectProjectAssociations(dbSession, organization, profile1, null))
}
@Test
- public void selectOutdatedProfiles_returns_the_custom_profiles_with_specified_name() {
- OrganizationDto org1 = dbTester.organizations().insert();
- OrganizationDto org2 = dbTester.organizations().insert();
- OrganizationDto org3 = dbTester.organizations().insert();
- QProfileDto outdatedProfile1 = dbTester.qualityProfiles().insert(org1, p -> p.setIsBuiltIn(false).setLanguage("java").setName("foo"));
- QProfileDto outdatedProfile2 = dbTester.qualityProfiles().insert(org2, p -> p.setIsBuiltIn(false).setLanguage("java").setName("foo"));
- QProfileDto builtInProfile = dbTester.qualityProfiles().insert(org3, p -> p.setIsBuiltIn(true).setLanguage("java").setName("foo"));
- QProfileDto differentLanguage = dbTester.qualityProfiles().insert(org1, p -> p.setIsBuiltIn(false).setLanguage("cobol").setName("foo"));
- QProfileDto differentName = dbTester.qualityProfiles().insert(org1, p -> p.setIsBuiltIn(false).setLanguage("java").setName("bar"));
+ public void selectUuidsOfCustomRulesProfiles_returns_the_custom_profiles_with_specified_name() {
+ OrganizationDto org1 = db.organizations().insert();
+ OrganizationDto org2 = db.organizations().insert();
+ OrganizationDto org3 = db.organizations().insert();
+ QProfileDto outdatedProfile1 = db.qualityProfiles().insert(org1, p -> p.setIsBuiltIn(false).setLanguage("java").setName("foo"));
+ QProfileDto outdatedProfile2 = db.qualityProfiles().insert(org2, p -> p.setIsBuiltIn(false).setLanguage("java").setName("foo"));
+ QProfileDto builtInProfile = db.qualityProfiles().insert(org3, p -> p.setIsBuiltIn(true).setLanguage("java").setName("foo"));
+ QProfileDto differentLanguage = db.qualityProfiles().insert(org1, p -> p.setIsBuiltIn(false).setLanguage("cobol").setName("foo"));
+ QProfileDto differentName = db.qualityProfiles().insert(org1, p -> p.setIsBuiltIn(false).setLanguage("java").setName("bar"));
Collection<String> keys = underTest.selectUuidsOfCustomRulesProfiles(dbSession, "java", "foo");
- assertThat(keys).containsExactlyInAnyOrder(outdatedProfile1.getKee(), outdatedProfile2.getKee());
+ assertThat(keys).containsExactlyInAnyOrder(outdatedProfile1.getRulesProfileUuid(), outdatedProfile2.getRulesProfileUuid());
}
@Test
@Test
public void renameAndCommit_updates_name_of_specified_profiles() {
- OrganizationDto org1 = dbTester.organizations().insert();
- OrganizationDto org2 = dbTester.organizations().insert();
- QProfileDto fooInOrg1 = dbTester.qualityProfiles().insert(org1, p -> p.setName("foo"));
- QProfileDto fooInOrg2 = dbTester.qualityProfiles().insert(org2, p -> p.setName("foo"));
- QProfileDto bar = dbTester.qualityProfiles().insert(org1, p -> p.setName("bar"));
+ OrganizationDto org1 = db.organizations().insert();
+ OrganizationDto org2 = db.organizations().insert();
+ QProfileDto fooInOrg1 = db.qualityProfiles().insert(org1, p -> p.setName("foo"));
+ QProfileDto fooInOrg2 = db.qualityProfiles().insert(org2, p -> p.setName("foo"));
+ QProfileDto bar = db.qualityProfiles().insert(org1, p -> p.setName("bar"));
- underTest.renameRulesProfilesAndCommit(dbSession, asList(fooInOrg1.getKee(), fooInOrg2.getKee()), "foo (copy)");
+ underTest.renameRulesProfilesAndCommit(dbSession, asList(fooInOrg1.getRulesProfileUuid(), fooInOrg2.getRulesProfileUuid()), "foo (copy)");
assertThat(underTest.selectOrFailByUuid(dbSession, fooInOrg1.getKee()).getName()).isEqualTo("foo (copy)");
assertThat(underTest.selectOrFailByUuid(dbSession, fooInOrg2.getKee()).getName()).isEqualTo("foo (copy)");
@Test
public void renameAndCommit_does_nothing_if_empty_keys() {
- OrganizationDto org = dbTester.organizations().insert();
- QProfileDto profile = dbTester.qualityProfiles().insert(org, p -> p.setName("foo"));
+ OrganizationDto org = db.organizations().insert();
+ QProfileDto profile = db.qualityProfiles().insert(org, p -> p.setName("foo"));
underTest.renameRulesProfilesAndCommit(dbSession, Collections.emptyList(), "foo (copy)");
}
private List<QProfileDto> createSharedData() {
- QProfileDto dto1 = QProfileDto.createFor("java_sonar_way")
+ QProfileDto dto1 = new QProfileDto()
+ .setKee("java_sonar_way")
+ .setRulesProfileUuid("rp-java_sonar_way")
.setOrganizationUuid(organization.getUuid())
.setName("Sonar Way")
.setLanguage("java")
.setIsBuiltIn(true);
underTest.insert(dbSession, dto1);
- QProfileDto dto2 = QProfileDto.createFor("js_sonar_way")
+ QProfileDto dto2 = new QProfileDto()
+ .setKee("js_sonar_way")
+ .setRulesProfileUuid("rp-js_sonar_way")
.setOrganizationUuid(organization.getUuid())
.setName("Sonar Way")
.setLanguage("js")
.setQProfileUuid(dto1.getKee())
.setLanguage(dto1.getLanguage())
.setOrganizationUuid(organization.getUuid());
- dbTester.getDbClient().defaultQProfileDao().insertOrUpdate(dbSession, DefaultQProfileDto.from(dto1));
+ db.getDbClient().defaultQProfileDao().insertOrUpdate(dbSession, DefaultQProfileDto.from(dto1));
return Arrays.asList(dto1, dto2);
}
*/
public static QProfileDto newQualityProfileDto() {
String uuid = Uuids.createFast();
- return QProfileDto.createFor(uuid)
+ return new QProfileDto()
+ .setKee(uuid)
+ .setRulesProfileUuid(Uuids.createFast())
.setOrganizationUuid(randomAlphanumeric(40))
.setName(uuid)
.setLanguage(randomAlphanumeric(20))
*/
public static QProfileChangeDto newQProfileChangeDto() {
return new QProfileChangeDto()
- .setKey(randomAlphanumeric(40))
- .setProfileKey(randomAlphanumeric(40))
+ .setUuid(randomAlphanumeric(40))
+ .setRulesProfileUuid(randomAlphanumeric(40))
.setCreatedAt(nextLong())
.setChangeType("ACTIVATED")
.setLogin(randomAlphanumeric(10));
return rule -> rule.setSystemTags(copyOf(tags));
}
- public static Consumer<RuleMetadataDto> setOrganizationUuid(String organizationUuid) {
- return rule -> rule.setOrganizationUuid(organizationUuid);
+ public static Consumer<RuleMetadataDto> setOrganization(OrganizationDto organization) {
+ return rule -> rule.setOrganizationUuid(organization.getUuid());
}
public static Consumer<RuleMetadataDto> setTags(String... tags) {
.add(1721, "Drop rules_profiles.is_default", DropIsDefaultColumnFromRulesProfiles.class)
.add(1722, "Create table qprofiles", CreateTableQProfiles.class)
.add(1723, "Populate table qprofiles", PopulateQProfiles.class)
- .add(1724, "Drop columns organization_uuid and parent_kee from rules_profiles", DropOrgUuidAndParentKeeFromRulesProfiles.class);
+ .add(1724, "Drop columns organization_uuid and parent_kee from rules_profiles", DropOrgUuidAndParentKeeFromRulesProfiles.class)
+ .add(1725, "Mark rules_profiles.is_built_in to true for default organization", SetRulesProfilesIsBuiltInToTrueForDefaultOrganization.class)
+ .add(1726, "Update OrgQProfiles to point to built-in profiles", UpdateOrgQProfilesToPointToBuiltInProfiles.class)
+ .add(1727, "Delete orphans rules_profiles table and associated tables", DeleteOrphansFromRulesProfiles.class);
}
}
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2017 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+package org.sonar.server.platform.db.migration.version.v65;
+
+import java.sql.SQLException;
+import org.sonar.db.Database;
+import org.sonar.server.platform.db.migration.step.DataChange;
+import org.sonar.server.platform.db.migration.step.MassUpdate;
+
+public class DeleteOrphansFromRulesProfiles extends DataChange {
+
+ public DeleteOrphansFromRulesProfiles(Database db) {
+ super(db);
+ }
+
+ @Override
+ protected void execute(Context context) throws SQLException {
+ deleteOrphansFromRulesProfiles(context);
+ deleteOrphansFromActiveRules(context);
+ deleteOrphansFromActiveRuleParameters(context);
+ deleteOrphansFromQProfileChanges(context);
+ }
+
+ private static void deleteOrphansFromRulesProfiles(Context context) throws SQLException {
+ MassUpdate massUpdate = context.prepareMassUpdate()
+ .rowPluralName("rules profiles");
+
+ massUpdate.select("select rp.kee " +
+ " from rules_profiles rp" +
+ " where not exists " +
+ " ( select 1 from org_qprofiles oqp where oqp.rules_profile_uuid = rp.kee )");
+
+ massUpdate.update("delete from rules_profiles where kee = ?")
+ .execute((row, update) -> {
+ String kee = row.getString(1);
+ update.setString(1, kee);
+ return true;
+ });
+ }
+
+ private static void deleteOrphansFromActiveRules(Context context) throws SQLException {
+ MassUpdate massUpdate = context.prepareMassUpdate()
+ .rowPluralName("active rules");
+
+ massUpdate.select("select ar.id " +
+ " from active_rules ar " +
+ " where not exists " +
+ " ( select 1 from rules_profiles rp where ar.profile_id = rp.id )");
+
+ massUpdate.update("delete from active_rules where id = ?")
+ .execute((row, update) -> {
+ int id = row.getInt(1);
+ update.setInt(1, id);
+ return true;
+ });
+ }
+
+ private static void deleteOrphansFromActiveRuleParameters(Context context) throws SQLException {
+ MassUpdate massUpdate = context.prepareMassUpdate()
+ .rowPluralName("active rule parameters");
+
+ massUpdate.select("select arp.id " +
+ " from active_rule_parameters arp " +
+ " where not exists " +
+ " ( select 1 from active_rules ar where ar.id = arp.active_rule_id )");
+
+ massUpdate.update("delete from active_rule_parameters where id = ?")
+ .execute((row, update) -> {
+ int id = row.getInt(1);
+ update.setInt(1, id);
+ return true;
+ });
+ }
+
+ private static void deleteOrphansFromQProfileChanges(Context context) throws SQLException {
+ MassUpdate massUpdate = context.prepareMassUpdate()
+ .rowPluralName("qprofile changes");
+
+ massUpdate.select("select qpc.kee " +
+ " from qprofile_changes qpc" +
+ " where not exists " +
+ " ( select 1 from rules_profiles rp where qpc.qprofile_key = rp.kee )");
+
+ massUpdate.update("delete from qprofile_changes where kee = ?")
+ .execute((row, update) -> {
+ String kee = row.getString(1);
+ update.setString(1, kee);
+ return true;
+ });
+ }
+
+}
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2017 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+package org.sonar.server.platform.db.migration.version.v65;
+
+import java.sql.SQLException;
+import org.sonar.db.Database;
+import org.sonar.server.platform.db.migration.step.DataChange;
+import org.sonar.server.platform.db.migration.step.MassUpdate;
+
+import static com.google.common.base.Preconditions.checkState;
+
+public class SetRulesProfilesIsBuiltInToTrueForDefaultOrganization extends DataChange {
+ private static final String PROP_DEFAULT_ORGANIZATION_UUID = "organization.default";
+ private static final String PROP_ORGANIZATION_ENABLED = "organization.enabled";
+
+ public SetRulesProfilesIsBuiltInToTrueForDefaultOrganization(Database db) {
+ super(db);
+ }
+
+ @Override
+ protected void execute(Context context) throws SQLException {
+ if (!isOrganizationEnabled(context)) {
+ return;
+ }
+
+ String defaultOrganizationUuid = getDefaultOrganizationUuid(context);
+ checkState(defaultOrganizationUuid!=null, "Missing internal property: '%s'", PROP_DEFAULT_ORGANIZATION_UUID);
+
+ MassUpdate massUpdate = context.prepareMassUpdate()
+ .rowPluralName("rules profiles");
+ massUpdate.select("select rp.kee " +
+ "from rules_profiles rp " +
+ "inner join org_qprofiles oqp on rp.kee = oqp.rules_profile_uuid " +
+ "where oqp.organization_uuid = ? ")
+ .setString(1, defaultOrganizationUuid);
+
+ massUpdate.update("update rules_profiles " +
+ "set is_built_in=? " +
+ "where kee=?").execute((row, update) -> {
+ String rulesProfilesUuid = row.getString(1);
+ update.setBoolean(1, true);
+ update.setString(2, rulesProfilesUuid);
+ return true;
+ });
+ }
+
+ private static String getDefaultOrganizationUuid(Context context) throws SQLException {
+ return context.prepareSelect("select text_value from internal_properties where kee=?")
+ .setString(1, PROP_DEFAULT_ORGANIZATION_UUID)
+ .get(row -> row.getString(1));
+ }
+
+ private static boolean isOrganizationEnabled(Context context) throws SQLException {
+ String value = context.prepareSelect("select text_value from internal_properties where kee=?")
+ .setString(1, PROP_ORGANIZATION_ENABLED)
+ .get(row -> row.getNullableString(1));
+
+ return "true".equals(value);
+ }
+}
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2017 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+package org.sonar.server.platform.db.migration.version.v65;
+
+import com.google.common.collect.HashBasedTable;
+import com.google.common.collect.Table;
+import java.sql.SQLException;
+import org.sonar.db.Database;
+import org.sonar.server.platform.db.migration.step.DataChange;
+import org.sonar.server.platform.db.migration.step.MassUpdate;
+
+import static com.google.common.base.Preconditions.checkState;
+
+public class UpdateOrgQProfilesToPointToBuiltInProfiles extends DataChange {
+ private static final String PROP_DEFAULT_ORGANIZATION_UUID = "organization.default";
+ private static final String PROP_ORGANIZATION_ENABLED = "organization.enabled";
+
+ public UpdateOrgQProfilesToPointToBuiltInProfiles(Database db) {
+ super(db);
+ }
+
+ @Override
+ protected void execute(Context context) throws SQLException {
+ if (!isOrganizationEnabled(context)) {
+ return;
+ }
+
+ String defaultOrganizationUuid = getDefaultOrganizationUuid(context);
+ BuiltInRulesProfiles builtInRulesProfiles = retrieveBuiltInRulesProfiles(context);
+
+ MassUpdate massUpdate = context.prepareMassUpdate()
+ .rowPluralName("org qprofiles");
+
+ massUpdate.select("select oqp.uuid, rp.language, rp.name " +
+ " from org_qprofiles oqp " +
+ " inner join rules_profiles rp on rp.kee = oqp.rules_profile_uuid " +
+ " where oqp.organization_uuid <> ? " +
+ " and rp.is_built_in = ? " +
+ " and rp.user_updated_at is null")
+ .setString(1, defaultOrganizationUuid)
+ .setBoolean(2, false);
+
+ massUpdate.update("update org_qprofiles " +
+ "set rules_profile_uuid = ? " +
+ "where uuid=?")
+ .execute((row, update) -> {
+ String orgQProfileUuid = row.getString(1);
+ String language = row.getString(2);
+ String name = row.getString(3);
+ if (!builtInRulesProfiles.contains(name, language)) {
+ return false;
+ }
+
+ update.setString(1, builtInRulesProfiles.get(name, language));
+ update.setString(2, orgQProfileUuid);
+ return true;
+ });
+ }
+
+ private static String getDefaultOrganizationUuid(Context context) throws SQLException {
+ String defaultOrganizationUuid = context.prepareSelect("select text_value from internal_properties where kee=?")
+ .setString(1, PROP_DEFAULT_ORGANIZATION_UUID)
+ .get(row -> row.getString(1));
+
+ checkState(defaultOrganizationUuid != null, "Missing internal property: '%s'", PROP_DEFAULT_ORGANIZATION_UUID);
+
+ return defaultOrganizationUuid;
+ }
+
+ private static boolean isOrganizationEnabled(Context context) throws SQLException {
+ String value = context.prepareSelect("select text_value from internal_properties where kee=?")
+ .setString(1, PROP_ORGANIZATION_ENABLED)
+ .get(row -> row.getNullableString(1));
+
+ return "true".equals(value);
+ }
+
+ private static BuiltInRulesProfiles retrieveBuiltInRulesProfiles(Context context) throws SQLException {
+ BuiltInRulesProfiles result = new BuiltInRulesProfiles();
+
+ context.prepareSelect("select name, language, kee" +
+ " from rules_profiles " +
+ " where is_built_in = ? ")
+ .setBoolean(1, true)
+ .list(row -> result.put(row.getString(1), row.getString(2), row.getString(3)));
+
+ return result;
+ }
+
+ private static class BuiltInRulesProfiles {
+ private Table<String, String, String> table = HashBasedTable.create();
+
+ private String put(String name, String language, String rulesProfileUuid) {
+ return table.put(name, language, rulesProfileUuid);
+ }
+
+ private boolean contains(String name, String language) {
+ return table.contains(name, language);
+ }
+
+ private String get(String name, String language) {
+ return table.get(name, language);
+ }
+ }
+
+}
@Test
public void verify_migration_count() {
- verifyMigrationCount(underTest, 25);
+ verifyMigrationCount(underTest, 28);
}
}
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2017 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+package org.sonar.server.platform.db.migration.version.v65;
+
+import java.sql.Date;
+import java.sql.SQLException;
+import java.util.List;
+import org.junit.Rule;
+import org.junit.Test;
+import org.sonar.core.util.stream.MoreCollectors;
+import org.sonar.db.CoreDbTester;
+
+import static java.lang.String.format;
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class DeleteOrphansFromRulesProfilesTest {
+
+ @Rule
+ public CoreDbTester db = CoreDbTester.createForSchema(DeleteOrphansFromRulesProfilesTest.class, "initial.sql");
+
+ private DeleteOrphansFromRulesProfiles underTest = new DeleteOrphansFromRulesProfiles(db.database());
+
+
+ @Test
+ public void migration() throws SQLException {
+ long rulesProfileId1 = insertRulesProfile("RP_UUID_1", "Sonar Way", "Java", 1_000L, true);
+ long rulesProfileId2 = insertRulesProfile("RP_UUID_2", "Sonar Way", "JavaScript", 1_000L, false);
+ insertRulesProfile("RP_UUID_3", "Sonar Way", "PL/SQL", 1_000L, false);
+ insertRulesProfile("RP_UUID_4", "Sonar Way", "Cobol", 1_000L, false);
+ insertRulesProfile("RP_UUID_5", "Sonar Way", "Cobol", 1_000L, false);
+ insertRulesProfile("RP_UUID_6", "Sonar Way", "Cobol", 1_000L, true);
+
+ insertOrgQProfile("ORG_QP_UUID_1", "ORG_UUID_1", "RP_UUID_1");
+ insertOrgQProfile("ORG_QP_UUID_2", "ORG_UUID_1", "RP_UUID_2");
+
+ long activeRuleId1 = insertActiveRule(rulesProfileId1, 1);
+ long activeRuleId2 = insertActiveRule(rulesProfileId2, 1);
+ insertActiveRule(-1, 1);
+ insertActiveRule(-2, 1);
+
+ long param1 = insertActiveRuleParameter(activeRuleId1, 1);
+ long param2 = insertActiveRuleParameter(activeRuleId1, 2);
+ long param3 = insertActiveRuleParameter(activeRuleId2, 2);
+ insertActiveRuleParameter(-1, 1);
+ insertActiveRuleParameter(-2, 1);
+
+ insertQProfileChange("QPC_UUID1", "RP_UUID_1", "A");
+ insertQProfileChange("QPC_UUID2", "RP_UUID_2", "B");
+ insertQProfileChange("QPC_UUID3", "RP_UUID_3", "A");
+ insertQProfileChange("QPC_UUID4", "RP_UUID_4", "A");
+
+ underTest.execute();
+
+ assertThat(selectRulesProfiles()).containsExactlyInAnyOrder("RP_UUID_1", "RP_UUID_2");
+ assertThat(selectActiveRules()).containsExactlyInAnyOrder(activeRuleId1, activeRuleId2);
+ assertThat(selectActiveRuleParameters()).containsExactlyInAnyOrder(param1, param2, param3);
+ assertThat(selectQProfileChanges()).containsExactlyInAnyOrder("QPC_UUID1", "QPC_UUID2");
+ }
+
+ @Test
+ public void delete_rules_profiles_without_reference_in_qprofiles() throws SQLException {
+ insertRulesProfile("RP_UUID_1", "Sonar Way", "Java", 1_000L, true);
+ insertRulesProfile("RP_UUID_2", "Sonar Way", "JavaScript", 1_000L, false);
+ insertRulesProfile("RP_UUID_5", "Sonar Way", "Cobol", 1_000L, false);
+ insertRulesProfile("RP_UUID_6", "Sonar Way", "Cobol", 1_000L, true);
+ insertOrgQProfile("ORG_QP_UUID_1", "ORG_UUID_1", "RP_UUID_5");
+ insertOrgQProfile("ORG_QP_UUID_2", "ORG_UUID_1", "RP_UUID_6");
+
+ underTest.execute();
+
+ assertThat(selectRulesProfiles()).containsExactlyInAnyOrder("RP_UUID_5", "RP_UUID_6");
+ }
+
+ @Test
+ public void delete_active_rules_without_rules_profiles() throws SQLException {
+ long rulesProfileId1 = insertRulesProfile("RP_UUID_1", "Sonar Way", "Java", 1_000L, true);
+ long rulesProfileId2 = insertRulesProfile("RP_UUID_2", "Sonar Way", "JavaScript", 1_000L, false);
+
+ insertOrgQProfile("ORG_QP_UUID_1", "ORG_UUID_1", "RP_UUID_1");
+ insertOrgQProfile("ORG_QP_UUID_2", "ORG_UUID_1", "RP_UUID_2");
+
+ long activeRule1 = insertActiveRule(rulesProfileId1, 1);
+ long activeRule2 = insertActiveRule(rulesProfileId2, 1);
+ insertActiveRule(-1, 1);
+ insertActiveRule(-2, 1);
+
+ underTest.execute();
+
+ assertThat(selectActiveRules()).containsExactlyInAnyOrder(activeRule1, activeRule2);
+ }
+
+ @Test
+ public void delete_active_rule_parameters_without_active_rules() throws SQLException {
+ long rulesProfileId1 = insertRulesProfile("RP_UUID_1", "Sonar Way", "Java", 1_000L, true);
+ long rulesProfileId2 = insertRulesProfile("RP_UUID_2", "Sonar Way", "JavaScript", 1_000L, false);
+
+ insertOrgQProfile("ORG_QP_UUID_1", "ORG_UUID_1", "RP_UUID_1");
+ insertOrgQProfile("ORG_QP_UUID_2", "ORG_UUID_1", "RP_UUID_2");
+
+ long activeRuleId1 = insertActiveRule(rulesProfileId1, 1);
+ long activeRuleId2 = insertActiveRule(rulesProfileId2, 1);
+
+ long param1 = insertActiveRuleParameter(activeRuleId1, 1);
+ long param2 = insertActiveRuleParameter(activeRuleId1, 2);
+ long param3 = insertActiveRuleParameter(activeRuleId2, 2);
+
+ insertActiveRuleParameter(-1, 1);
+ insertActiveRuleParameter(-2, 1);
+
+ underTest.execute();
+
+ assertThat(selectActiveRuleParameters()).containsExactlyInAnyOrder(param1, param2, param3);
+ }
+
+ @Test
+ public void delete_qprofile_changes_without_rules_profiles() throws SQLException {
+ long rulesProfileId1 = insertRulesProfile("RP_UUID_1", "Sonar Way", "Java", 1_000L, true);
+ long rulesProfileId2 = insertRulesProfile("RP_UUID_2", "Sonar Way", "JavaScript", 1_000L, false);
+
+ insertOrgQProfile("ORG_QP_UUID_1", "ORG_UUID_1", "RP_UUID_1");
+ insertOrgQProfile("ORG_QP_UUID_2", "ORG_UUID_1", "RP_UUID_2");
+
+ insertQProfileChange("QPC_UUID1", "RP_UUID_1", "A");
+ insertQProfileChange("QPC_UUID2", "RP_UUID_2", "B");
+ insertQProfileChange("QPC_UUID3", "RP_UUID_3", "A");
+ insertQProfileChange("QPC_UUID4", "RP_UUID_4", "A");
+
+ underTest.execute();
+
+ assertThat(selectQProfileChanges()).containsExactlyInAnyOrder("QPC_UUID1", "QPC_UUID2");
+ }
+
+ @Test
+ public void reentrant_migration() throws SQLException {
+ long rulesProfileId1 = insertRulesProfile("RP_UUID_1", "Sonar Way", "Java", 1_000L, true);
+ long rulesProfileId2 = insertRulesProfile("RP_UUID_2", "Sonar Way", "JavaScript", 1_000L, false);
+ insertRulesProfile("RP_UUID_3", "Sonar Way", "PL/SQL", 1_000L, false);
+ insertRulesProfile("RP_UUID_4", "Sonar Way", "Cobol", 1_000L, false);
+ insertRulesProfile("RP_UUID_5", "Sonar Way", "Cobol", 1_000L, false);
+ insertRulesProfile("RP_UUID_6", "Sonar Way", "Cobol", 1_000L, true);
+
+ insertOrgQProfile("ORG_QP_UUID_1", "ORG_UUID_1", "RP_UUID_1");
+ insertOrgQProfile("ORG_QP_UUID_2", "ORG_UUID_1", "RP_UUID_2");
+
+ long activeRuleId1 = insertActiveRule(rulesProfileId1, 1);
+ long activeRuleId2 = insertActiveRule(rulesProfileId2, 1);
+ insertActiveRule(-1, 1);
+ insertActiveRule(-2, 1);
+
+ insertActiveRuleParameter(activeRuleId1, 1);
+ insertActiveRuleParameter(activeRuleId1, 2);
+ insertActiveRuleParameter(activeRuleId2, 2);
+ insertActiveRuleParameter(-1, 1);
+ insertActiveRuleParameter(-2, 1);
+
+ insertQProfileChange("QPC_UUID1", "RP_UUID_1", "A");
+ insertQProfileChange("QPC_UUID2", "RP_UUID_2", "B");
+ insertQProfileChange("QPC_UUID3", "RP_UUID_3", "A");
+ insertQProfileChange("QPC_UUID4", "RP_UUID_4", "A");
+
+ underTest.execute();
+ underTest.execute();
+
+ assertThat(countRows("rules_profiles")).isEqualTo(2);
+ assertThat(countRows("active_rules")).isEqualTo(2);
+ assertThat(countRows("active_rule_parameters")).isEqualTo(3);
+ assertThat(countRows("qprofile_changes")).isEqualTo(2);
+ }
+
+ private int countRows(String table) {
+ return db.countSql(format("select count(*) from %s", table));
+ }
+
+ private List<String> selectRulesProfiles() {
+ return db.select("select kee as \"kee\" from rules_profiles")
+ .stream()
+ .map(row -> (String) row.get("kee"))
+ .collect(MoreCollectors.toList());
+ }
+
+ private List<String> selectQProfileChanges() {
+ return db.select("select kee as \"kee\" from qprofile_changes")
+ .stream()
+ .map(row -> (String) row.get("kee"))
+ .collect(MoreCollectors.toList());
+ }
+
+ private List<Long> selectActiveRules() {
+ return db.select("select id as \"id\" from active_rules")
+ .stream()
+ .map(row -> (Long) row.get("id"))
+ .collect(MoreCollectors.toList());
+ }
+
+ private List<Long> selectActiveRuleParameters() {
+ return db.select("select id as \"id\" from active_rule_parameters")
+ .stream()
+ .map(row -> (Long) row.get("id"))
+ .collect(MoreCollectors.toList());
+ }
+
+ private long insertRulesProfile(String rulesProfileUuid, String name, String language, Long userUpdatedAt, boolean isBuiltIn) {
+ db.executeInsert("RULES_PROFILES",
+ "NAME", name,
+ "LANGUAGE", language,
+ "KEE", rulesProfileUuid,
+ "USER_UPDATED_AT", userUpdatedAt,
+ "IS_BUILT_IN", isBuiltIn,
+ "LAST_USED", 1_000L,
+ "CREATED_AT", new Date(1_000L),
+ "UPDATED_AT", new Date(1_000L));
+
+ return (Long) db.selectFirst(
+ format("select id as \"id\" from rules_profiles where kee='%s'", rulesProfileUuid)).get("id");
+ }
+
+ private void insertOrgQProfile(String orgQProfileUuid, String orgUuid, String rulesProfileUuid) {
+ db.executeInsert("ORG_QPROFILES",
+ "UUID", orgQProfileUuid,
+ "ORGANIZATION_UUID", orgUuid,
+ "RULES_PROFILE_UUID", rulesProfileUuid,
+ "CREATED_AT", 1_000L,
+ "UPDATED_AT", 2_000L);
+ }
+
+ private long insertActiveRule(long profileId, long ruleId) {
+ db.executeInsert("ACTIVE_RULES",
+ "PROFILE_ID", profileId,
+ "RULE_ID", ruleId,
+ "FAILURE_LEVEL", 1,
+ "INHERITANCE", "",
+ "CREATED_AT", 1_000L,
+ "UPDATED_AT", 2_000L);
+
+ return (Long) db.selectFirst(
+ format("select id as \"id\" from active_rules where profile_id = %d and rule_id = %d", profileId, ruleId)).get("id");
+ }
+
+ private long insertActiveRuleParameter(long activeRuleId, long rulesParameterId) {
+ db.executeInsert("ACTIVE_RULE_PARAMETERS",
+ "ACTIVE_RULE_ID", activeRuleId,
+ "RULES_PARAMETER_ID", rulesParameterId,
+ "RULES_PARAMETER_KEY", "",
+ "VALUE", "");
+
+ return (Long) db.selectFirst(
+ format("select id as \"id\" from active_rule_parameters where active_rule_id=%d and rules_parameter_id=%d", activeRuleId, rulesParameterId)).get("id");
+ }
+
+ private void insertQProfileChange(String uuid, String rulesProfileUuid, String changeType) {
+ db.executeInsert("QPROFILE_CHANGES",
+ "KEE", uuid,
+ "QPROFILE_KEY", rulesProfileUuid,
+ "CHANGE_TYPE", changeType,
+ "USER_LOGIN", "",
+ "CHANGE_DATA", "",
+ "CREATED_AT", 1_000L);
+ }
+}
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2017 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+package org.sonar.server.platform.db.migration.version.v65;
+
+import java.sql.SQLException;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.sonar.db.CoreDbTester;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class SetRulesProfilesIsBuiltInToTrueForDefaultOrganizationTest {
+
+ @Rule
+ public ExpectedException expectedException = ExpectedException.none();
+
+ @Rule
+ public CoreDbTester db = CoreDbTester.createForSchema(SetRulesProfilesIsBuiltInToTrueForDefaultOrganizationTest.class, "initial.sql");
+
+ private SetRulesProfilesIsBuiltInToTrueForDefaultOrganization underTest = new SetRulesProfilesIsBuiltInToTrueForDefaultOrganization(db.database());
+
+ @Test
+ public void has_no_effect_if_table_is_empty() throws SQLException {
+ underTest.execute();
+
+ assertThat(db.countRowsOfTable("rules_profiles")).isEqualTo(0);
+ }
+
+ @Test
+ public void mark_rules_profiles_of_default_org_as_built_in() throws SQLException {
+ enableOrganization();
+ String defaultOrganizationUuid = "ORG_UUID_1";
+ setDefaultOrganization(defaultOrganizationUuid);
+ IntStream.rangeClosed(1, 3).forEach(i -> {
+ insertProfile(defaultOrganizationUuid, "RP_UUID_" + i, false);
+ insertProfile("ORG_UUID_404", "RP_UUID_404_" + i, false);
+ });
+
+ underTest.execute();
+
+ assertThat(selectRulesProfiles(true)).containsExactlyInAnyOrder("RP_UUID_1", "RP_UUID_2", "RP_UUID_3");
+ assertThat(selectRulesProfiles(false)).containsExactlyInAnyOrder("RP_UUID_404_1", "RP_UUID_404_2", "RP_UUID_404_3");
+ }
+
+ @Test
+ public void do_nothing_if_org_disabled() throws SQLException {
+ String defaultOrganizationUuid = "ORG_UUID_1";
+ setDefaultOrganization(defaultOrganizationUuid);
+ IntStream.rangeClosed(1, 3).forEach(i -> {
+ insertProfile(defaultOrganizationUuid, "RP_UUID_" + i, false);
+ insertProfile("ORG_UUID_404", "RP_UUID_404_" + i, false);
+ });
+
+ underTest.execute();
+
+ assertThat(selectRulesProfiles(false)).containsExactlyInAnyOrder("RP_UUID_1", "RP_UUID_2", "RP_UUID_3", "RP_UUID_404_1", "RP_UUID_404_2", "RP_UUID_404_3");
+ }
+
+ @Test
+ public void reentrant_migration() throws SQLException {
+ enableOrganization();
+ String defaultOrganizationUuid = "ORG_UUID_1";
+ setDefaultOrganization(defaultOrganizationUuid);
+ IntStream.rangeClosed(1, 3).forEach(i -> {
+ insertProfile(defaultOrganizationUuid, "RP_UUID_" + i, false);
+ insertProfile("ORG_UUID_404", "RP_UUID_404_" + i, false);
+ });
+
+ underTest.execute();
+ underTest.execute();
+
+ assertThat(selectRulesProfiles(true)).containsExactlyInAnyOrder("RP_UUID_1", "RP_UUID_2", "RP_UUID_3");
+ assertThat(selectRulesProfiles(false)).containsExactlyInAnyOrder("RP_UUID_404_1", "RP_UUID_404_2", "RP_UUID_404_3");
+ }
+
+ @Test
+ public void reentrant_of_crashed_migration() throws SQLException {
+ enableOrganization();
+ String defaultOrganizationUuid = "ORG_UUID_1";
+ setDefaultOrganization(defaultOrganizationUuid);
+ insertProfile(defaultOrganizationUuid, "RP_UUID_1", true);
+ insertProfile(defaultOrganizationUuid, "RP_UUID_2", false);
+ insertProfile(defaultOrganizationUuid, "RP_UUID_3", false);
+
+ underTest.execute();
+
+ assertThat(selectRulesProfiles(true)).containsExactlyInAnyOrder("RP_UUID_1", "RP_UUID_2", "RP_UUID_3");
+ }
+
+ @Test
+ public void fail_if_no_default_org_and_org_activated() throws SQLException {
+ enableOrganization();
+ insertProfile("ORG_UUID_1", "RP_UUID_1", false);
+
+ expectedException.expect(IllegalStateException.class);
+ expectedException.expectMessage("Missing internal property: 'organization.default'");
+
+ underTest.execute();
+ }
+
+ private Set<String> selectRulesProfiles(boolean isBuiltIn) {
+ return db.select("select rp.kee as \"uuid\", rp.is_built_in as \"isBuiltIn\" from rules_profiles rp")
+ .stream()
+ .filter(row -> (boolean) row.get("isBuiltIn") == isBuiltIn)
+ .map(row -> (String) row.get("uuid"))
+ .collect(Collectors.toSet());
+ }
+
+ private void enableOrganization() {
+ db.executeInsert("INTERNAL_PROPERTIES",
+ "KEE", "organization.enabled",
+ "TEXT_VALUE", "true",
+ "IS_EMPTY", false);
+ }
+
+ private void setDefaultOrganization(String uuid) {
+ db.executeInsert("INTERNAL_PROPERTIES",
+ "KEE", "organization.default",
+ "TEXT_VALUE", uuid,
+ "IS_EMPTY", false);
+ }
+
+ private void insertProfile(String orgUuid, String rulesProfileUuid, boolean isBuiltIn) {
+ db.executeInsert("ORG_QPROFILES",
+ "ORGANIZATION_UUID", orgUuid,
+ "UUID", "OQP_UUID_" + rulesProfileUuid,
+ "RULES_PROFILE_UUID", rulesProfileUuid,
+ "CREATED_AT", 1_000L,
+ "UPDATED_AT", 2_000L);
+ db.executeInsert("RULES_PROFILES",
+ "NAME", "name_" + rulesProfileUuid,
+ "KEE", rulesProfileUuid,
+ "LANGUAGE", "LANG_" + rulesProfileUuid,
+ "IS_BUILT_IN", isBuiltIn);
+ }
+}
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2017 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+package org.sonar.server.platform.db.migration.version.v65;
+
+import java.sql.SQLException;
+import java.util.List;
+import javax.annotation.Nullable;
+import org.assertj.core.groups.Tuple;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.sonar.core.util.stream.MoreCollectors;
+import org.sonar.db.CoreDbTester;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.tuple;
+
+public class UpdateOrgQProfilesToPointToBuiltInProfilesTest {
+
+ @Rule
+ public ExpectedException expectedException = ExpectedException.none();
+
+ @Rule
+ public CoreDbTester db = CoreDbTester.createForSchema(UpdateOrgQProfilesToPointToBuiltInProfilesTest.class, "initial.sql");
+
+ private UpdateOrgQProfilesToPointToBuiltInProfiles underTest = new UpdateOrgQProfilesToPointToBuiltInProfiles(db.database());
+
+ @Test
+ public void has_no_effect_if_table_is_empty() throws SQLException {
+ underTest.execute();
+
+ assertThat(db.countRowsOfTable("rules_profiles")).isEqualTo(0);
+ }
+
+ @Test
+ public void has_no_effect_if_organization_are_disabled() throws SQLException {
+ String defaultOrgUuid = "DEFAULT_ORG_UUID";
+ setDefaultOrganization(defaultOrgUuid);
+ String sonarWayJava = "RP_UUID_1";
+ String sonarWayJavascript = "RP_UUID_2";
+ insertProfile(defaultOrgUuid, "OQP_UUID_1", sonarWayJava, "Sonar way", "Java", true, 1_000_000_000L);
+ insertProfile(defaultOrgUuid, "OQP_UUID_2", sonarWayJavascript, "Sonar way", "Javascript", true, null);
+ insertProfile(defaultOrgUuid, "OQP_UUID_3", "RP_UUID_3", "Sonar way", "Cobol", true, null);
+ insertProfile(defaultOrgUuid, "OQP_UUID_4", "RP_UUID_4", "My Sonar way", "Java", false, null);
+
+ underTest.execute();
+
+ assertThat(selectRulesProfiles()).containsExactlyInAnyOrder(
+ tuple("OQP_UUID_1", sonarWayJava),
+ tuple("OQP_UUID_2", sonarWayJavascript),
+ tuple("OQP_UUID_3", "RP_UUID_3"),
+ tuple("OQP_UUID_4", "RP_UUID_4"));
+ }
+
+ @Test
+ public void update_org_qprofiles_to_point_to_built_in_rules_profiles() throws SQLException {
+ enableOrganization();
+ String defaultOrgUuid = "DEFAULT_ORG_UUID";
+ setDefaultOrganization(defaultOrgUuid);
+ String sonarWayJava = "RP_UUID_1";
+ String sonarWayJavascript = "RP_UUID_2";
+ insertProfile(defaultOrgUuid, "OQP_UUID_1", sonarWayJava, "Sonar way", "Java", true, 1_000_000_000L);
+ insertProfile(defaultOrgUuid, "OQP_UUID_2", sonarWayJavascript, "Sonar way", "Javascript", true, null);
+ insertProfile(defaultOrgUuid, "OQP_UUID_3", "RP_UUID_3", "Sonar way", "Cobol", true, null);
+ insertProfile("ORG_UUID_1", "OQP_UUID_4", "RP_UUID_4", "Sonar way", "Java", false, null);
+ insertProfile("ORG_UUID_1", "OQP_UUID_5", "RP_UUID_5", "My Sonar way", "Java", false, null);
+ insertProfile("ORG_UUID_2", "OQP_UUID_6", "RP_UUID_6", "Sonar way", "Javascript", false, null);
+ insertProfile("ORG_UUID_2", "OQP_UUID_7", "RP_UUID_7", "Sonar way", "Python", false, null);
+ insertProfile("ORG_UUID_2", "OQP_UUID_8", "RP_UUID_8", "Sonar way", "Java", false, 2_000_000_000L);
+
+ underTest.execute();
+
+ assertThat(selectRulesProfiles()).containsExactlyInAnyOrder(
+ tuple("OQP_UUID_1", sonarWayJava),
+ tuple("OQP_UUID_2", sonarWayJavascript),
+ tuple("OQP_UUID_3", "RP_UUID_3"),
+ tuple("OQP_UUID_4", sonarWayJava),
+ tuple("OQP_UUID_5", "RP_UUID_5"),
+ tuple("OQP_UUID_6", sonarWayJavascript),
+ tuple("OQP_UUID_7", "RP_UUID_7"),
+ tuple("OQP_UUID_8", "RP_UUID_8"));
+ }
+
+ @Test
+ public void migration_is_reentrant() throws SQLException {
+ enableOrganization();
+ String defaultOrgUuid = "DEFAULT_ORG_UUID";
+ setDefaultOrganization(defaultOrgUuid);
+ String sonarWayJava = "RP_UUID_1";
+ String sonarWayJavascript = "RP_UUID_2";
+ insertProfile(defaultOrgUuid, "OQP_UUID_1", sonarWayJava, "Sonar way", "Java", true, 1_000_000_000L);
+ insertProfile(defaultOrgUuid, "OQP_UUID_2", sonarWayJavascript, "Sonar way", "Javascript", true, null);
+ insertProfile("ORG_UUID_1", "OQP_UUID_4", "RP_UUID_4", "Sonar way", "Java", false, null);
+ insertProfile("ORG_UUID_1", "OQP_UUID_5", "RP_UUID_5", "My Sonar way", "Java", false, null);
+
+ underTest.execute();
+ underTest.execute();
+
+ assertThat(selectRulesProfiles()).containsExactlyInAnyOrder(
+ tuple("OQP_UUID_1", sonarWayJava),
+ tuple("OQP_UUID_2", sonarWayJavascript),
+ tuple("OQP_UUID_4", sonarWayJava),
+ tuple("OQP_UUID_5", "RP_UUID_5"));
+ }
+
+ @Test
+ public void crashed_migration_is_reentrant() throws SQLException {
+ enableOrganization();
+ String defaultOrgUuid = "DEFAULT_ORG_UUID";
+ setDefaultOrganization(defaultOrgUuid);
+ String sonarWayJava = "RP_UUID_1";
+ String sonarWayJavascript = "RP_UUID_2";
+ insertProfile(defaultOrgUuid, "OQP_UUID_1", sonarWayJava, "Sonar way", "Java", true, 1_000_000_000L);
+ insertProfile(defaultOrgUuid, "OQP_UUID_2", sonarWayJavascript, "Sonar way", "Javascript", true, null);
+ insertOrgQProfile("ORG_UUID_1", "OQP_UUID_3", sonarWayJava);
+ insertProfile("ORG_UUID_1", "OQP_UUID_4", "RP_UUID_4", "Sonar way", "Javascript", false, null);
+ insertProfile("ORG_UUID_1", "OQP_UUID_5", "RP_UUID_5", "My Sonar way", "Java", false, null);
+
+ underTest.execute();
+
+ assertThat(selectRulesProfiles()).containsExactlyInAnyOrder(
+ tuple("OQP_UUID_1", sonarWayJava),
+ tuple("OQP_UUID_2", sonarWayJavascript),
+ tuple("OQP_UUID_3", sonarWayJava),
+ tuple("OQP_UUID_4", sonarWayJavascript),
+ tuple("OQP_UUID_5", "RP_UUID_5"));
+ }
+
+ @Test
+ public void fail_if_no_default_org_and_org_activated() throws SQLException {
+ enableOrganization();
+
+ expectedException.expect(IllegalStateException.class);
+ expectedException.expectMessage("Missing internal property: 'organization.default'");
+
+ underTest.execute();
+ }
+
+ private List<Tuple> selectRulesProfiles() {
+ return db.select("select oqp.uuid as \"uuid\", oqp.rules_profile_uuid as \"rulesProfileUuid\" from org_qprofiles oqp")
+ .stream()
+ .map(row -> tuple(row.get("uuid"), row.get("rulesProfileUuid")))
+ .collect(MoreCollectors.toList());
+ }
+
+ private void enableOrganization() {
+ db.executeInsert("INTERNAL_PROPERTIES",
+ "KEE", "organization.enabled",
+ "TEXT_VALUE", "true",
+ "IS_EMPTY", false);
+ }
+
+ private void setDefaultOrganization(String uuid) {
+ db.executeInsert("INTERNAL_PROPERTIES",
+ "KEE", "organization.default",
+ "TEXT_VALUE", uuid,
+ "IS_EMPTY", false);
+ }
+
+ private void insertProfile(String orgUuid, String orgQProfileUuid, String rulesProfileUuid, String name, String language, boolean isBuiltIn, @Nullable Long userUpdatedAt) {
+ db.executeInsert("ORG_QPROFILES",
+ "ORGANIZATION_UUID", orgUuid,
+ "UUID", orgQProfileUuid,
+ "RULES_PROFILE_UUID", rulesProfileUuid,
+ "CREATED_AT", 1_000L,
+ "UPDATED_AT", 2_000L);
+ db.executeInsert("RULES_PROFILES",
+ "NAME", name,
+ "KEE", rulesProfileUuid,
+ "LANGUAGE", language,
+ "IS_BUILT_IN", isBuiltIn,
+ "USER_UPDATED_AT", userUpdatedAt);
+ }
+
+ private void insertOrgQProfile(String orgUuid, String orgQProfileUuid, String rulesProfileUuid) {
+ db.executeInsert("ORG_QPROFILES",
+ "ORGANIZATION_UUID", orgUuid,
+ "UUID", orgQProfileUuid,
+ "RULES_PROFILE_UUID", rulesProfileUuid,
+ "CREATED_AT", 1_000L,
+ "UPDATED_AT", 2_000L);
+ }
+}
--- /dev/null
+CREATE TABLE "RULES_PROFILES" (
+ "ID" INTEGER NOT NULL GENERATED BY DEFAULT AS IDENTITY (START WITH 1, INCREMENT BY 1),
+ "NAME" VARCHAR(100) NOT NULL,
+ "LANGUAGE" VARCHAR(20),
+ "KEE" VARCHAR(255) NOT NULL,
+ "RULES_UPDATED_AT" VARCHAR(100),
+ "CREATED_AT" TIMESTAMP,
+ "UPDATED_AT" TIMESTAMP,
+ "LAST_USED" BIGINT,
+ "USER_UPDATED_AT" BIGINT,
+ "IS_BUILT_IN" BOOLEAN NOT NULL
+);
+CREATE UNIQUE INDEX "UNIQ_QPROF_KEY" ON "RULES_PROFILES" ("KEE");
+
+CREATE TABLE "ORG_QPROFILES" (
+ "UUID" VARCHAR(40) NOT NULL PRIMARY KEY,
+ "ORGANIZATION_UUID" VARCHAR(40) NOT NULL,
+ "RULES_PROFILE_UUID" VARCHAR(40) NOT NULL,
+ "PARENT_UUID" VARCHAR(40),
+ "CREATED_AT" BIGINT NOT NULL,
+ "UPDATED_AT" BIGINT NOT NULL
+);
+CREATE INDEX "ORG_QPROFILES_ORG_UUID" ON "ORG_QPROFILES" ("ORGANIZATION_UUID");
+CREATE INDEX "ORG_QPROFILES_RP_UUID" ON "ORG_QPROFILES" ("RULES_PROFILE_UUID");
+
+
+CREATE TABLE "ACTIVE_RULES" (
+ "ID" INTEGER NOT NULL GENERATED BY DEFAULT AS IDENTITY (START WITH 1, INCREMENT BY 1),
+ "PROFILE_ID" INTEGER NOT NULL,
+ "RULE_ID" INTEGER NOT NULL,
+ "FAILURE_LEVEL" INTEGER NOT NULL,
+ "INHERITANCE" VARCHAR(10),
+ "CREATED_AT" BIGINT,
+ "UPDATED_AT" BIGINT
+);
+CREATE UNIQUE INDEX "ACTIVE_RULES_UNIQUE" ON "ACTIVE_RULES" ("PROFILE_ID","RULE_ID");
+
+
+CREATE TABLE "ACTIVE_RULE_PARAMETERS" (
+ "ID" INTEGER NOT NULL GENERATED BY DEFAULT AS IDENTITY (START WITH 1, INCREMENT BY 1),
+ "ACTIVE_RULE_ID" INTEGER NOT NULL,
+ "RULES_PARAMETER_ID" INTEGER NOT NULL,
+ "RULES_PARAMETER_KEY" VARCHAR(128),
+ "VALUE" VARCHAR(4000)
+);
+CREATE INDEX "IX_ARP_ON_ACTIVE_RULE_ID" ON "ACTIVE_RULE_PARAMETERS" ("ACTIVE_RULE_ID");
+
+
+CREATE TABLE "QPROFILE_CHANGES" (
+ "KEE" VARCHAR(40) NOT NULL PRIMARY KEY,
+ "QPROFILE_KEY" VARCHAR(255) NOT NULL,
+ "CHANGE_TYPE" VARCHAR(20) NOT NULL,
+ "CREATED_AT" BIGINT NOT NULL,
+ "USER_LOGIN" VARCHAR(255),
+ "CHANGE_DATA" CLOB
+);
+CREATE INDEX "QPROFILE_CHANGES_QPROFILE_KEY" ON "QPROFILE_CHANGES" ("QPROFILE_KEY");
--- /dev/null
+CREATE TABLE "RULES_PROFILES" (
+ "ID" INTEGER NOT NULL GENERATED BY DEFAULT AS IDENTITY (START WITH 1, INCREMENT BY 1),
+ "NAME" VARCHAR(100) NOT NULL,
+ "LANGUAGE" VARCHAR(20),
+ "KEE" VARCHAR(255) NOT NULL,
+ "RULES_UPDATED_AT" VARCHAR(100),
+ "CREATED_AT" TIMESTAMP,
+ "UPDATED_AT" TIMESTAMP,
+ "LAST_USED" BIGINT,
+ "USER_UPDATED_AT" BIGINT,
+ "IS_BUILT_IN" BOOLEAN NOT NULL
+);
+CREATE UNIQUE INDEX "UNIQ_QPROF_KEY" ON "RULES_PROFILES" ("KEE");
+
+CREATE TABLE "ORG_QPROFILES" (
+ "UUID" VARCHAR(40) NOT NULL PRIMARY KEY,
+ "ORGANIZATION_UUID" VARCHAR(40) NOT NULL,
+ "RULES_PROFILE_UUID" VARCHAR(40) NOT NULL,
+ "PARENT_UUID" VARCHAR(40),
+ "CREATED_AT" BIGINT NOT NULL,
+ "UPDATED_AT" BIGINT NOT NULL
+);
+CREATE INDEX "ORG_QPROFILES_ORG_UUID" ON "ORG_QPROFILES" ("ORGANIZATION_UUID");
+CREATE INDEX "ORG_QPROFILES_RP_UUID" ON "ORG_QPROFILES" ("RULES_PROFILE_UUID");
+
+
+CREATE TABLE "INTERNAL_PROPERTIES" (
+ "KEE" VARCHAR(50) NOT NULL PRIMARY KEY,
+ "IS_EMPTY" BOOLEAN NOT NULL,
+ "TEXT_VALUE" VARCHAR(4000),
+ "CLOB_VALUE" CLOB,
+ "CREATED_AT" BIGINT
+);
+CREATE UNIQUE INDEX "UNIQ_INTERNAL_PROPERTIES" ON "INTERNAL_PROPERTIES" ("KEE");
--- /dev/null
+CREATE TABLE "RULES_PROFILES" (
+ "ID" INTEGER NOT NULL GENERATED BY DEFAULT AS IDENTITY (START WITH 1, INCREMENT BY 1),
+ "NAME" VARCHAR(100) NOT NULL,
+ "LANGUAGE" VARCHAR(20),
+ "KEE" VARCHAR(255) NOT NULL,
+ "RULES_UPDATED_AT" VARCHAR(100),
+ "CREATED_AT" TIMESTAMP,
+ "UPDATED_AT" TIMESTAMP,
+ "LAST_USED" BIGINT,
+ "USER_UPDATED_AT" BIGINT,
+ "IS_BUILT_IN" BOOLEAN NOT NULL
+);
+CREATE UNIQUE INDEX "UNIQ_QPROF_KEY" ON "RULES_PROFILES" ("KEE");
+
+CREATE TABLE "ORG_QPROFILES" (
+ "UUID" VARCHAR(40) NOT NULL PRIMARY KEY,
+ "ORGANIZATION_UUID" VARCHAR(40) NOT NULL,
+ "RULES_PROFILE_UUID" VARCHAR(40) NOT NULL,
+ "PARENT_UUID" VARCHAR(40),
+ "CREATED_AT" BIGINT NOT NULL,
+ "UPDATED_AT" BIGINT NOT NULL
+);
+CREATE INDEX "ORG_QPROFILES_ORG_UUID" ON "ORG_QPROFILES" ("ORGANIZATION_UUID");
+CREATE INDEX "ORG_QPROFILES_RP_UUID" ON "ORG_QPROFILES" ("RULES_PROFILE_UUID");
+
+CREATE TABLE "INTERNAL_PROPERTIES" (
+ "KEE" VARCHAR(50) NOT NULL PRIMARY KEY,
+ "IS_EMPTY" BOOLEAN NOT NULL,
+ "TEXT_VALUE" VARCHAR(4000),
+ "CLOB_VALUE" CLOB,
+ "CREATED_AT" BIGINT
+);
+CREATE UNIQUE INDEX "UNIQ_INTERNAL_PROPERTIES" ON "INTERNAL_PROPERTIES" ("KEE");
package org.sonar.server.es;
import java.util.Date;
+import java.util.HashMap;
import java.util.Map;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
-import static com.google.common.collect.Maps.newHashMap;
-
/**
* Base implementation for business objects based on elasticsearch document
*/
protected final Map<String, Object> fields;
protected BaseDoc() {
- this.fields = newHashMap();
+ this.fields = new HashMap<>();
}
protected BaseDoc(Map<String, Object> fields) {
}
public void addDeletion(IndexType indexType, String id) {
- add(client.prepareDelete(indexType, id).request());
+ add(client.prepareDelete(indexType, id).setRouting(id).request());
}
public void addDeletion(IndexType indexType, String id, String routing) {
}
public IssueIterator createForAll() {
- return createForProject((String) null);
+ return createForProject(null);
}
public IssueIterator createForProject(@Nullable String projectUuid) {
*/
package org.sonar.server.organization;
+import java.util.ArrayList;
import java.util.Date;
+import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.function.Consumer;
import javax.annotation.Nullable;
import org.sonar.api.config.Settings;
import org.sonar.api.utils.System2;
-import org.sonar.api.utils.log.Logger;
-import org.sonar.api.utils.log.Loggers;
import org.sonar.core.config.CorePropertyDefinitions;
import org.sonar.core.util.UuidFactory;
import org.sonar.db.DbClient;
import org.sonar.db.permission.UserPermissionDto;
import org.sonar.db.permission.template.PermissionTemplateCharacteristicDto;
import org.sonar.db.permission.template.PermissionTemplateDto;
+import org.sonar.db.qualityprofile.DefaultQProfileDto;
+import org.sonar.db.qualityprofile.OrgQProfileDto;
import org.sonar.db.user.GroupDto;
import org.sonar.db.user.UserDto;
import org.sonar.db.user.UserGroupDto;
import org.sonar.server.qualityprofile.BuiltInQProfile;
-import org.sonar.server.qualityprofile.BuiltInQProfileInsert;
import org.sonar.server.qualityprofile.BuiltInQProfileRepository;
-import org.sonar.server.qualityprofile.index.ActiveRuleIndexer;
+import org.sonar.server.qualityprofile.QProfileName;
import org.sonar.server.user.index.UserIndexer;
import org.sonar.server.usergroups.DefaultGroupCreator;
import static org.sonar.api.web.UserRole.CODEVIEWER;
import static org.sonar.api.web.UserRole.ISSUE_ADMIN;
import static org.sonar.api.web.UserRole.USER;
+import static org.sonar.core.util.stream.MoreCollectors.uniqueIndex;
import static org.sonar.db.permission.OrganizationPermission.SCAN;
import static org.sonar.server.organization.OrganizationCreation.NewOrganization.newOrganizationBuilder;
public class OrganizationCreationImpl implements OrganizationCreation {
- private static final Logger LOGGER = Loggers.get(OrganizationCreationImpl.class);
private final DbClient dbClient;
private final System2 system2;
private final OrganizationValidation organizationValidation;
private final Settings settings;
private final BuiltInQProfileRepository builtInQProfileRepository;
- private final BuiltInQProfileInsert builtInQProfileInsert;
private final DefaultGroupCreator defaultGroupCreator;
private final UserIndexer userIndexer;
- private final ActiveRuleIndexer activeRuleIndexer;
public OrganizationCreationImpl(DbClient dbClient, System2 system2, UuidFactory uuidFactory,
OrganizationValidation organizationValidation, Settings settings, UserIndexer userIndexer,
- BuiltInQProfileRepository builtInQProfileRepository, BuiltInQProfileInsert builtInQProfileInsert,
- DefaultGroupCreator defaultGroupCreator, ActiveRuleIndexer activeRuleIndexer) {
+ BuiltInQProfileRepository builtInQProfileRepository,
+ DefaultGroupCreator defaultGroupCreator) {
this.dbClient = dbClient;
this.system2 = system2;
this.uuidFactory = uuidFactory;
this.settings = settings;
this.userIndexer = userIndexer;
this.builtInQProfileRepository = builtInQProfileRepository;
- this.builtInQProfileInsert = builtInQProfileInsert;
this.defaultGroupCreator = defaultGroupCreator;
- this.activeRuleIndexer = activeRuleIndexer;
}
@Override
dbSession.commit();
batchDbSession.commit();
- activeRuleIndexer.index();
// Elasticsearch is updated when DB session is committed
userIndexer.index(userCreator.getLogin());
dbSession.commit();
batchDbSession.commit();
- activeRuleIndexer.index();
// Elasticsearch is updated when DB session is committed
userIndexer.index(newUser.getLogin());
}
private void insertQualityProfiles(DbSession dbSession, DbSession batchDbSession, OrganizationDto organization) {
- builtInQProfileRepository.getQProfilesByLanguage().entrySet()
- .stream()
- .flatMap(entry -> entry.getValue().stream())
- .forEach(profile -> insertQualityProfile(dbSession, batchDbSession, profile, organization));
- }
-
- private void insertQualityProfile(DbSession regularSession, DbSession batchDbSession, BuiltInQProfile profile, OrganizationDto organization) {
- LOGGER.debug("Creating quality profile {} for language {} for organization {}", profile.getName(), profile.getLanguage(), organization.getKey());
+ Map<QProfileName, BuiltInQProfile> builtInsPerName = builtInQProfileRepository.get().stream()
+ .collect(uniqueIndex(BuiltInQProfile::getQProfileName));
+
+ List<DefaultQProfileDto> defaults = new ArrayList<>();
+ dbClient.qualityProfileDao().selectBuiltInRulesProfiles(dbSession).forEach(rulesProfile -> {
+ OrgQProfileDto dto = new OrgQProfileDto()
+ .setOrganizationUuid(organization.getUuid())
+ .setRulesProfileUuid(rulesProfile.getKee())
+ .setUuid(uuidFactory.create());
+
+ QProfileName name = new QProfileName(rulesProfile.getLanguage(), rulesProfile.getName());
+ BuiltInQProfile builtIn = builtInsPerName.get(name);
+ if (builtIn != null && builtIn.isDefault()) {
+ // rows of table default_qprofiles must be inserted after org_qprofiles
+ // in order to benefit from batch SQL inserts
+ defaults.add(new DefaultQProfileDto()
+ .setQProfileUuid(dto.getUuid())
+ .setOrganizationUuid(organization.getUuid())
+ .setLanguage(builtIn.getLanguage()));
+ }
+
+ dbClient.qualityProfileDao().insert(batchDbSession, dto);
+ });
- builtInQProfileInsert.create(regularSession, batchDbSession, profile, organization);
+ defaults.forEach(defaultQProfileDto -> dbClient.defaultQProfileDao().insertOrUpdate(dbSession, defaultQProfileDto));
}
/**
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.Response;
import org.sonar.api.server.ws.WebService;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import org.sonar.db.component.ComponentDto;
}
private void deleteQualityProfiles(DbSession dbSession, OrganizationDto organization) {
- List<QProfileDto> profiles = dbClient.qualityProfileDao().selectAll(dbSession, organization);
- List<String> profileKeys = profiles.stream()
- .map(QProfileDto::getKee)
- .collect(MoreCollectors.toArrayList(profiles.size()));
- qProfileFactory.deleteByKeys(dbSession, profileKeys);
- dbSession.commit();
+ List<QProfileDto> profiles = dbClient.qualityProfileDao().selectOrderedByOrganizationUuid(dbSession, organization);
+ qProfileFactory.delete(dbSession, profiles);
}
private void deleteOrganization(DbSession dbSession, OrganizationDto organization) {
import org.sonar.server.property.InternalPropertiesImpl;
import org.sonar.server.property.ws.PropertiesWs;
import org.sonar.server.qualitygate.QualityGateModule;
-import org.sonar.server.qualityprofile.BuiltInQProfileInsertImpl;
import org.sonar.server.qualityprofile.BuiltInQProfileRepositoryImpl;
import org.sonar.server.qualityprofile.QProfileBackuperImpl;
import org.sonar.server.qualityprofile.QProfileComparison;
import org.sonar.server.qualityprofile.RuleActivator;
import org.sonar.server.qualityprofile.RuleActivatorContextFactory;
import org.sonar.server.qualityprofile.index.ActiveRuleIndexer;
+import org.sonar.server.qualityprofile.index.ActiveRuleIteratorFactory;
import org.sonar.server.qualityprofile.ws.OldRestoreAction;
import org.sonar.server.qualityprofile.ws.ProfilesWs;
import org.sonar.server.qualityprofile.ws.QProfilesWsModule;
// quality profile
BuiltInQProfileRepositoryImpl.class,
- BuiltInQProfileInsertImpl.class,
+ ActiveRuleIteratorFactory.class,
ActiveRuleIndexer.class,
XMLProfileParser.class,
XMLProfileSerializer.class,
import org.sonar.server.platform.ServerLifecycleNotifier;
import org.sonar.server.platform.web.RegisterServletFilters;
import org.sonar.server.qualitygate.RegisterQualityGates;
+import org.sonar.server.qualityprofile.BuiltInQProfileInsertImpl;
import org.sonar.server.qualityprofile.BuiltInQProfileLoader;
import org.sonar.server.qualityprofile.RegisterQualityProfiles;
import org.sonar.server.rule.RegisterRules;
RegisterRules.class);
add(BuiltInQProfileLoader.class);
addIfStartupLeader(
+ BuiltInQProfileInsertImpl.class,
RegisterQualityProfiles.class,
RegisterPermissionTemplates.class,
RenameDeprecatedPropertyKeys.class,
package org.sonar.server.qualityprofile;
import com.google.common.base.MoreObjects;
-import com.google.common.collect.Maps;
import java.util.HashMap;
import java.util.Map;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
import org.apache.commons.lang.StringUtils;
+import org.sonar.db.qualityprofile.ActiveRuleDto;
import org.sonar.db.qualityprofile.ActiveRuleKey;
import org.sonar.db.qualityprofile.QProfileChangeDto;
public class ActiveRuleChange {
+ private ActiveRuleDto activeRule;
+
public enum Type {
ACTIVATED, DEACTIVATED, UPDATED
}
private final ActiveRuleKey key;
private String severity = null;
private ActiveRule.Inheritance inheritance = null;
- private Map<String, String> parameters = Maps.newHashMap();
+ private final Map<String, String> parameters = new HashMap<>();
+
+ public ActiveRuleChange(Type type, ActiveRuleDto activeRule) {
+ this.type = type;
+ this.key = activeRule.getKey();
+ this.activeRule = activeRule;
+ }
- private ActiveRuleChange(Type type, ActiveRuleKey key) {
+ public ActiveRuleChange(Type type, ActiveRuleKey key) {
this.type = type;
this.key = key;
}
return this;
}
+ @CheckForNull
+ public ActiveRuleDto getActiveRule() {
+ return activeRule;
+ }
+
+ public ActiveRuleChange setActiveRule(@Nullable ActiveRuleDto activeRule) {
+ this.activeRule = activeRule;
+ return this;
+ }
+
public QProfileChangeDto toDto(@Nullable String login) {
QProfileChangeDto dto = new QProfileChangeDto();
dto.setChangeType(type.name());
- dto.setProfileKey(getKey().qProfile());
+ dto.setRulesProfileUuid(getKey().getRuleProfileUuid());
dto.setLogin(login);
Map<String, String> data = new HashMap<>();
- data.put("key", getKey().toString());
- data.put("ruleKey", getKey().ruleKey().toString());
+ data.put("ruleKey", getKey().getRuleKey().toString());
parameters.entrySet().stream()
.filter(param -> !param.getKey().isEmpty())
return dto;
}
- public static ActiveRuleChange createFor(Type type, ActiveRuleKey key) {
- return new ActiveRuleChange(type, key);
- }
-
@Override
public String toString() {
return MoreObjects.toStringHelper(this)
private final List<org.sonar.api.rules.ActiveRule> activeRules;
private BuiltInQProfile(Builder builder) {
- this.qProfileName = new QProfileName(builder.language, builder.getName());
+ this.qProfileName = new QProfileName(builder.language, builder.name);
this.isDefault = builder.declaredDefault || builder.computedDefault;
this.activeRules = ImmutableList.copyOf(builder.activeRules);
}
package org.sonar.server.qualityprofile;
import org.sonar.db.DbSession;
-import org.sonar.db.organization.OrganizationDto;
public interface BuiltInQProfileInsert {
- void create(DbSession session, DbSession batchSession, BuiltInQProfile builtInQProfile, OrganizationDto organization);
+ /**
+ * Persist a built-in profile and associate it to all existing organizations.
+ * Db sessions are committed.
+ */
+ void create(DbSession session, DbSession batchSession, BuiltInQProfile builtInQProfile);
}
import com.google.common.base.Splitter;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Sets;
+import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
-import org.sonar.db.organization.OrganizationDto;
import org.sonar.db.qualityprofile.ActiveRuleDto;
import org.sonar.db.qualityprofile.ActiveRuleKey;
import org.sonar.db.qualityprofile.ActiveRuleParamDto;
import org.sonar.db.qualityprofile.DefaultQProfileDto;
-import org.sonar.db.qualityprofile.QProfileDto;
+import org.sonar.db.qualityprofile.OrgQProfileDto;
+import org.sonar.db.qualityprofile.RulesProfileDto;
import org.sonar.db.rule.RuleDefinitionDto;
import org.sonar.db.rule.RuleParamDto;
+import org.sonar.server.qualityprofile.index.ActiveRuleIndexer;
import org.sonar.server.util.TypeValidations;
import static com.google.common.base.MoreObjects.firstNonNull;
private final System2 system2;
private final UuidFactory uuidFactory;
private final TypeValidations typeValidations;
+ private final ActiveRuleIndexer activeRuleIndexer;
private RuleRepository ruleRepository;
- public BuiltInQProfileInsertImpl(DbClient dbClient, System2 system2, UuidFactory uuidFactory, TypeValidations typeValidations) {
+ public BuiltInQProfileInsertImpl(DbClient dbClient, System2 system2, UuidFactory uuidFactory, TypeValidations typeValidations, ActiveRuleIndexer activeRuleIndexer) {
this.dbClient = dbClient;
this.system2 = system2;
this.uuidFactory = uuidFactory;
this.typeValidations = typeValidations;
+ this.activeRuleIndexer = activeRuleIndexer;
}
@Override
- public void create(DbSession session, DbSession batchSession, BuiltInQProfile builtInQProfile, OrganizationDto organization) {
- initRuleRepository(batchSession);
+ public void create(DbSession dbSession, DbSession batchDbSession, BuiltInQProfile builtInQProfile) {
+ initRuleRepository(batchDbSession);
Date now = new Date(system2.now());
- QProfileDto profileDto = insertQualityProfile(session, builtInQProfile, organization, now);
+ RulesProfileDto ruleProfile = insertRulesProfile(dbSession, builtInQProfile, now);
List<ActiveRuleChange> localChanges = builtInQProfile.getActiveRules()
.stream()
- .map(activeRule -> insertActiveRule(session, profileDto, activeRule, now.getTime()))
+ .map(activeRule -> insertActiveRule(dbSession, ruleProfile, activeRule, now.getTime()))
.collect(MoreCollectors.toList());
- localChanges.forEach(change -> dbClient.qProfileChangeDao().insert(batchSession, change.toDto(null)));
+ localChanges.forEach(change -> dbClient.qProfileChangeDao().insert(batchDbSession, change.toDto(null)));
+
+ associateToOrganizations(dbSession, batchDbSession, builtInQProfile, ruleProfile);
+
+ dbSession.commit();
+ batchDbSession.commit();
+
+ activeRuleIndexer.indexRuleProfile(dbSession, ruleProfile);
}
- private void initRuleRepository(DbSession session) {
+ private void associateToOrganizations(DbSession dbSession, DbSession batchDbSession, BuiltInQProfile builtInQProfile, RulesProfileDto rulesProfileDto) {
+ List<String> orgUuids = dbClient.organizationDao().selectAllUuids(dbSession);
+
+ List<DefaultQProfileDto> defaults = new ArrayList<>();
+ orgUuids.forEach(orgUuid -> {
+ OrgQProfileDto dto = new OrgQProfileDto()
+ .setOrganizationUuid(orgUuid)
+ .setRulesProfileUuid(rulesProfileDto.getKee())
+ .setUuid(uuidFactory.create());
+
+ if (builtInQProfile.isDefault()) {
+ // rows of table default_qprofiles must be inserted after
+ // in order to benefit from batch SQL inserts
+ defaults.add(new DefaultQProfileDto()
+ .setQProfileUuid(dto.getUuid())
+ .setOrganizationUuid(orgUuid)
+ .setLanguage(builtInQProfile.getLanguage()));
+ }
+
+ dbClient.qualityProfileDao().insert(batchDbSession, dto);
+ });
+
+ defaults.forEach(defaultQProfileDto -> dbClient.defaultQProfileDao().insertOrUpdate(dbSession, defaultQProfileDto));
+ }
+
+ private void initRuleRepository(DbSession dbSession) {
if (ruleRepository == null) {
- ruleRepository = new RuleRepository(dbClient, session);
+ ruleRepository = new RuleRepository(dbClient, dbSession);
}
}
- private QProfileDto insertQualityProfile(DbSession dbSession, BuiltInQProfile builtInQProfile, OrganizationDto organization, Date now) {
- QProfileDto profileDto = QProfileDto.createFor(uuidFactory.create())
- .setName(builtInQProfile.getName())
- .setOrganizationUuid(organization.getUuid())
- .setLanguage(builtInQProfile.getLanguage())
+ private RulesProfileDto insertRulesProfile(DbSession dbSession, BuiltInQProfile builtIn, Date now) {
+ RulesProfileDto dto = new RulesProfileDto()
+ .setKee(uuidFactory.create())
+ .setName(builtIn.getName())
+ .setLanguage(builtIn.getLanguage())
.setIsBuiltIn(true)
.setRulesUpdatedAtAsDate(now);
- dbClient.qualityProfileDao().insert(dbSession, profileDto);
- if (builtInQProfile.isDefault()) {
- dbClient.defaultQProfileDao().insertOrUpdate(dbSession, DefaultQProfileDto.from(profileDto));
- }
- return profileDto;
+ dbClient.qualityProfileDao().insert(dbSession, dto);
+ return dto;
}
- private ActiveRuleChange insertActiveRule(DbSession session, QProfileDto profileDto, org.sonar.api.rules.ActiveRule activeRule, long now) {
+ private ActiveRuleChange insertActiveRule(DbSession dbSession, RulesProfileDto rulesProfileDto, org.sonar.api.rules.ActiveRule activeRule, long now) {
RuleKey ruleKey = RuleKey.of(activeRule.getRepositoryKey(), activeRule.getRuleKey());
RuleDefinitionDto ruleDefinitionDto = ruleRepository.getDefinition(ruleKey)
.orElseThrow(() -> new IllegalStateException("RuleDefinition not found for key " + ruleKey));
- ActiveRuleDto dto = ActiveRuleDto.createFor(profileDto, ruleDefinitionDto);
+ ActiveRuleDto dto = new ActiveRuleDto();
+ dto.setProfileId(rulesProfileDto.getId());
+ dto.setRuleId(ruleDefinitionDto.getId());
+ dto.setKey(ActiveRuleKey.of(rulesProfileDto, ruleDefinitionDto.getKey()));
dto.setSeverity(firstNonNull(activeRule.getSeverity().name(), ruleDefinitionDto.getSeverityString()));
dto.setUpdatedAt(now);
dto.setCreatedAt(now);
- dbClient.activeRuleDao().insert(session, dto);
+ dbClient.activeRuleDao().insert(dbSession, dto);
- List<ActiveRuleParamDto> paramDtos = insertActiveRuleParams(session, activeRule, ruleKey, dto);
+ List<ActiveRuleParamDto> paramDtos = insertActiveRuleParams(dbSession, activeRule, ruleKey, dto);
- ActiveRuleChange change = ActiveRuleChange.createFor(ActiveRuleChange.Type.ACTIVATED, ActiveRuleKey.of(profileDto.getKee(), ruleKey));
+ ActiveRuleChange change = new ActiveRuleChange(ActiveRuleChange.Type.ACTIVATED, dto);
change.setSeverity(dto.getSeverityString());
paramDtos.forEach(paramDto -> change.setParameter(paramDto.getKey(), paramDto.getValue()));
return change;
return value;
}
- public static class RuleRepository {
- private final Map<RuleKey, RuleDefinitionDto> ruleDefinitions;
- private final Map<RuleKey, Set<RuleParamDto>> ruleParams;
+ private static class RuleRepository {
+ private final Map<RuleKey, RuleDefinitionDto> definitions;
+ private final Map<RuleKey, Set<RuleParamDto>> params;
private RuleRepository(DbClient dbClient, DbSession session) {
- this.ruleDefinitions = dbClient.ruleDao().selectAllDefinitions(session)
+ this.definitions = dbClient.ruleDao().selectAllDefinitions(session)
.stream()
.collect(Collectors.toMap(RuleDefinitionDto::getKey, Function.identity()));
- Map<Integer, RuleKey> ruleIdsByKey = ruleDefinitions.values()
+ Map<Integer, RuleKey> ruleIdsByKey = definitions.values()
.stream()
.collect(MoreCollectors.uniqueIndex(RuleDefinitionDto::getId, RuleDefinitionDto::getKey));
- this.ruleParams = new HashMap<>(ruleIdsByKey.size());
- dbClient.ruleDao().selectRuleParamsByRuleKeys(session, ruleDefinitions.keySet())
- .forEach(ruleParam -> ruleParams.compute(
+ this.params = new HashMap<>(ruleIdsByKey.size());
+ dbClient.ruleDao().selectRuleParamsByRuleKeys(session, definitions.keySet())
+ .forEach(ruleParam -> params.compute(
ruleIdsByKey.get(ruleParam.getRuleId()),
(key, value) -> {
if (value == null) {
}));
}
- Optional<RuleDefinitionDto> getDefinition(RuleKey ruleKey) {
- return Optional.ofNullable(ruleDefinitions.get(requireNonNull(ruleKey, "RuleKey can't be null")));
+ private Optional<RuleDefinitionDto> getDefinition(RuleKey ruleKey) {
+ return Optional.ofNullable(definitions.get(requireNonNull(ruleKey, "RuleKey can't be null")));
}
- Set<RuleParamDto> getRuleParams(RuleKey ruleKey) {
- Set<RuleParamDto> res = ruleParams.get(requireNonNull(ruleKey, "RuleKey can't be null"));
+ private Set<RuleParamDto> getRuleParams(RuleKey ruleKey) {
+ Set<RuleParamDto> res = params.get(requireNonNull(ruleKey, "RuleKey can't be null"));
return res == null ? Collections.emptySet() : res;
}
}
package org.sonar.server.qualityprofile;
import java.util.List;
-import java.util.Map;
public interface BuiltInQProfileRepository {
/**
void initialize();
/**
- * @return an immutable map containing immutable lists.
+ * @return an immutable list
*
* @throws IllegalStateException if {@link #initialize()} has not been called
*/
- Map<String, List<BuiltInQProfile>> getQProfilesByLanguage();
+ List<BuiltInQProfile> get();
}
private final Languages languages;
private final List<ProfileDefinition> definitions;
- private Map<String, List<BuiltInQProfile>> qProfilesByLanguage;
+ private List<BuiltInQProfile> qProfiles;
/**
* Requires for pico container when no {@link ProfileDefinition} is defined at all
@Override
public void initialize() {
- checkState(qProfilesByLanguage == null, "initialize must be called only once");
+ checkState(qProfiles == null, "initialize must be called only once");
Profiler profiler = Profiler.create(Loggers.get(getClass())).startInfo("Load quality profiles");
ListMultimap<String, RulesProfile> rulesProfilesByLanguage = buildRulesProfilesByLanguage();
validateAndClean(rulesProfilesByLanguage);
- this.qProfilesByLanguage = toQualityProfilesByLanguage(rulesProfilesByLanguage);
+ this.qProfiles = toFlatList(rulesProfilesByLanguage);
profiler.stopDebug();
}
@Override
- public Map<String, List<BuiltInQProfile>> getQProfilesByLanguage() {
- checkState(qProfilesByLanguage != null, "initialize must be called first");
+ public List<BuiltInQProfile> get() {
+ checkState(qProfiles != null, "initialize must be called first");
- return qProfilesByLanguage;
+ return qProfiles;
}
/**
});
}
- private static Map<String, List<BuiltInQProfile>> toQualityProfilesByLanguage(ListMultimap<String, RulesProfile> rulesProfilesByLanguage) {
+ private static List<BuiltInQProfile> toFlatList(ListMultimap<String, RulesProfile> rulesProfilesByLanguage) {
Map<String, List<BuiltInQProfile.Builder>> buildersByLanguage = Multimaps.asMap(rulesProfilesByLanguage)
.entrySet()
.stream()
.entrySet()
.stream()
.filter(BuiltInQProfileRepositoryImpl::ensureAtMostOneDeclaredDefault)
- .collect(MoreCollectors.uniqueIndex(Map.Entry::getKey, entry -> toQualityProfiles(entry.getValue()), buildersByLanguage.size()));
+ .map(entry -> toQualityProfiles(entry.getValue()))
+ .flatMap(Collection::stream)
+ .collect(MoreCollectors.toList());
}
/**
import org.sonar.db.organization.OrganizationDto;
import org.sonar.db.qualityprofile.ActiveRuleDto;
import org.sonar.db.qualityprofile.ActiveRuleParamDto;
+import org.sonar.db.qualityprofile.OrgActiveRuleDto;
import org.sonar.db.qualityprofile.QProfileDto;
import static com.google.common.base.Preconditions.checkArgument;
}
@Override
- public void backup(DbSession dbSession, QProfileDto profileDto, Writer writer) {
- List<ActiveRuleDto> activeRules = db.activeRuleDao().selectByProfileKey(dbSession, profileDto.getKee());
+ public void backup(DbSession dbSession, QProfileDto profile, Writer writer) {
+ List<OrgActiveRuleDto> activeRules = db.activeRuleDao().selectByProfile(dbSession, profile);
activeRules.sort(BackupActiveRuleComparator.INSTANCE);
- writeXml(dbSession, writer, profileDto, activeRules.iterator());
+ writeXml(dbSession, writer, profile, activeRules.iterator());
}
- private void writeXml(DbSession dbSession, Writer writer, QProfileDto profile, Iterator<ActiveRuleDto> activeRules) {
+ private void writeXml(DbSession dbSession, Writer writer, QProfileDto profile, Iterator<OrgActiveRuleDto> activeRules) {
XmlWriter xml = XmlWriter.of(writer).declaration();
xml.begin(ATTRIBUTE_PROFILE);
xml.prop(ATTRIBUTE_NAME, profile.getName());
while (activeRules.hasNext()) {
ActiveRuleDto activeRule = activeRules.next();
xml.begin(ATTRIBUTE_RULE);
- xml.prop(ATTRIBUTE_REPOSITORY_KEY, activeRule.getKey().ruleKey().repository());
- xml.prop(ATTRIBUTE_KEY, activeRule.getKey().ruleKey().rule());
+ xml.prop(ATTRIBUTE_REPOSITORY_KEY, activeRule.getRuleKey().repository());
+ xml.prop(ATTRIBUTE_KEY, activeRule.getRuleKey().rule());
xml.prop(ATTRIBUTE_PRIORITY, activeRule.getSeverityString());
xml.begin(ATTRIBUTE_PARAMETERS);
for (ActiveRuleParamDto param : db.activeRuleDao().selectParamsByActiveRuleId(dbSession, activeRule.getId())) {
@Override
public int compare(ActiveRuleDto o1, ActiveRuleDto o2) {
return new CompareToBuilder()
- .append(o1.getKey().ruleKey().repository(), o2.getKey().ruleKey().repository())
- .append(o1.getKey().ruleKey().rule(), o2.getKey().ruleKey().rule())
+ .append(o1.getRuleKey().repository(), o2.getRuleKey().repository())
+ .append(o1.getRuleKey().rule(), o2.getRuleKey().rule())
.toComparison();
}
}
import org.sonar.db.DbSession;
import org.sonar.db.qualityprofile.ActiveRuleDto;
import org.sonar.db.qualityprofile.ActiveRuleParamDto;
+import org.sonar.db.qualityprofile.OrgActiveRuleDto;
import org.sonar.db.qualityprofile.QProfileDto;
@ServerSide
}
public QProfileComparisonResult compare(DbSession dbSession, QProfileDto left, QProfileDto right) {
- Map<RuleKey, ActiveRuleDto> leftActiveRulesByRuleKey = loadActiveRules(dbSession, left);
- Map<RuleKey, ActiveRuleDto> rightActiveRulesByRuleKey = loadActiveRules(dbSession, right);
+ Map<RuleKey, OrgActiveRuleDto> leftActiveRulesByRuleKey = loadActiveRules(dbSession, left);
+ Map<RuleKey, OrgActiveRuleDto> rightActiveRulesByRuleKey = loadActiveRules(dbSession, right);
Set<RuleKey> allRules = Sets.newHashSet();
allRules.addAll(leftActiveRulesByRuleKey.keySet());
}
private void compareActivationParams(DbSession session, ActiveRuleDto leftRule, ActiveRuleDto rightRule, QProfileComparisonResult result) {
- RuleKey key = leftRule.getKey().ruleKey();
+ RuleKey key = leftRule.getRuleKey();
Map<String, String> leftParams = paramDtoToMap(dbClient.activeRuleDao().selectParamsByActiveRuleId(session, leftRule.getId()));
Map<String, String> rightParams = paramDtoToMap(dbClient.activeRuleDao().selectParamsByActiveRuleId(session, rightRule.getId()));
if (leftParams.equals(rightParams) && leftRule.getSeverityString().equals(rightRule.getSeverityString())) {
}
}
- private Map<RuleKey, ActiveRuleDto> loadActiveRules(DbSession session, QProfileDto profile) {
- return Maps.uniqueIndex(dbClient.activeRuleDao().selectByProfileKey(session, profile.getKee()), ActiveRuleToRuleKey.INSTANCE);
+ private Map<RuleKey, OrgActiveRuleDto> loadActiveRules(DbSession dbSession, QProfileDto profile) {
+ return Maps.uniqueIndex(dbClient.activeRuleDao().selectByProfile(dbSession, profile), ActiveRuleToRuleKey.INSTANCE);
}
public static class QProfileComparisonResult {
@Override
public RuleKey apply(@Nonnull ActiveRuleDto input) {
- return input.getKey().ruleKey();
+ return input.getRuleKey();
}
}
import org.sonar.db.DbSession;
import org.sonar.db.qualityprofile.ActiveRuleDto;
import org.sonar.db.qualityprofile.ActiveRuleParamDto;
+import org.sonar.db.qualityprofile.OrgActiveRuleDto;
import org.sonar.db.qualityprofile.QProfileDto;
import org.sonar.server.exceptions.BadRequestException;
import org.sonar.server.exceptions.NotFoundException;
return exporter.getMimeType();
}
- public void export(QProfileDto profile, String exporterKey, Writer writer) {
+ public void export(DbSession dbSession, QProfileDto profile, String exporterKey, Writer writer) {
ProfileExporter exporter = findExporter(exporterKey);
- exporter.exportProfile(wrap(profile), writer);
+ exporter.exportProfile(wrap(dbSession, profile), writer);
}
- private RulesProfile wrap(QProfileDto profile) {
- try (DbSession dbSession = dbClient.openSession(false)) {
- RulesProfile target = new RulesProfile(profile.getName(), profile.getLanguage());
- List<ActiveRuleDto> activeRuleDtos = dbClient.activeRuleDao().selectByProfileKey(dbSession, profile.getKee());
- List<ActiveRuleParamDto> activeRuleParamDtos = dbClient.activeRuleDao().selectParamsByActiveRuleIds(dbSession, Lists.transform(activeRuleDtos, ActiveRuleDto::getId));
- ListMultimap<Integer, ActiveRuleParamDto> activeRuleParamsByActiveRuleId = FluentIterable.from(activeRuleParamDtos).index(ActiveRuleParamDto::getActiveRuleId);
-
- for (ActiveRuleDto activeRule : activeRuleDtos) {
- // TODO all rules should be loaded by using one query with all active rule keys as parameter
- Rule rule = ruleFinder.findByKey(activeRule.getKey().ruleKey());
- org.sonar.api.rules.ActiveRule wrappedActiveRule = target.activateRule(rule, RulePriority.valueOf(activeRule.getSeverityString()));
- List<ActiveRuleParamDto> paramDtos = activeRuleParamsByActiveRuleId.get(activeRule.getId());
- for (ActiveRuleParamDto activeRuleParamDto : paramDtos) {
- wrappedActiveRule.setParameter(activeRuleParamDto.getKey(), activeRuleParamDto.getValue());
- }
+ private RulesProfile wrap(DbSession dbSession, QProfileDto profile) {
+ RulesProfile target = new RulesProfile(profile.getName(), profile.getLanguage());
+ List<OrgActiveRuleDto> activeRuleDtos = dbClient.activeRuleDao().selectByProfile(dbSession, profile);
+ List<ActiveRuleParamDto> activeRuleParamDtos = dbClient.activeRuleDao().selectParamsByActiveRuleIds(dbSession, Lists.transform(activeRuleDtos, ActiveRuleDto::getId));
+ ListMultimap<Integer, ActiveRuleParamDto> activeRuleParamsByActiveRuleId = FluentIterable.from(activeRuleParamDtos).index(ActiveRuleParamDto::getActiveRuleId);
+
+ for (ActiveRuleDto activeRule : activeRuleDtos) {
+ // TODO all rules should be loaded by using one query with all active rule keys as parameter
+ Rule rule = ruleFinder.findByKey(activeRule.getRuleKey());
+ org.sonar.api.rules.ActiveRule wrappedActiveRule = target.activateRule(rule, RulePriority.valueOf(activeRule.getSeverityString()));
+ List<ActiveRuleParamDto> paramDtos = activeRuleParamsByActiveRuleId.get(activeRule.getId());
+ for (ActiveRuleParamDto activeRuleParamDto : paramDtos) {
+ wrappedActiveRule.setParameter(activeRuleParamDto.getKey(), activeRuleParamDto.getValue());
}
- return target;
}
+ return target;
}
private ProfileExporter findExporter(String exporterKey) {
*/
package org.sonar.server.qualityprofile;
+import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
+import java.util.HashSet;
+import java.util.List;
import java.util.Objects;
+import java.util.Set;
import javax.annotation.Nullable;
import org.apache.commons.lang.StringUtils;
import org.sonar.api.utils.System2;
return doCreate(dbSession, organization, name, false, false);
}
- /**
- * Create the quality profile in DB with the specified name.
- *
- * A DB error will be thrown if the quality profile already exists.
- */
- public QProfileDto createBuiltIn(DbSession dbSession, OrganizationDto organization, QProfileName name, boolean isDefault) {
- return doCreate(dbSession, requireNonNull(organization), name, isDefault, true);
- }
-
private QProfileDto doCreate(DbSession dbSession, OrganizationDto organization, QProfileName name, boolean isDefault, boolean isBuiltIn) {
if (StringUtils.isEmpty(name.getName())) {
throw BadRequestException.create("quality_profiles.profile_name_cant_be_blank");
}
Date now = new Date(system2.now());
- QProfileDto dto = QProfileDto.createFor(uuidFactory.create())
+ QProfileDto dto = new QProfileDto()
+ .setKee(uuidFactory.create())
+ .setRulesProfileUuid(uuidFactory.create())
.setName(name.getName())
.setOrganizationUuid(organization.getUuid())
.setLanguage(name.getLanguage())
}
// ------------- DELETION
-
/**
- * Deletes the profiles with specified keys from database and Elasticsearch.
- * All related information are deleted. The profiles marked as "default"
- * are deleted too. Deleting a parent profile does not delete descendants
- * if their keys are not listed.
+ * Deletes the specified profiles from database and Elasticsearch.
+ * All information related to custom profiles are deleted. Only association
+ * with built-in profiles are deleted.
+ * The profiles marked as "default" are deleted too. Deleting a parent profile
+ * does not delete descendants if the latter are not listed.
*/
- public void deleteByKeys(DbSession dbSession, Collection<String> profileUuids) {
- if (!profileUuids.isEmpty()) {
- db.qualityProfileDao().deleteProjectAssociationsByProfileUuids(dbSession, profileUuids);
- db.activeRuleDao().deleteParametersByProfileKeys(dbSession, profileUuids);
- db.activeRuleDao().deleteByProfileKeys(dbSession, profileUuids);
- db.qProfileChangeDao().deleteByProfileKeys(dbSession, profileUuids);
- db.defaultQProfileDao().deleteByQProfileUuids(dbSession, profileUuids);
- db.qualityProfileDao().deleteByUuids(dbSession, profileUuids);
- dbSession.commit();
- activeRuleIndexer.deleteByProfileKeys(profileUuids);
+ public void delete(DbSession dbSession, Collection<QProfileDto> profiles) {
+ if (profiles.isEmpty()) {
+ return;
}
- }
+ Set<String> uuids = new HashSet<>();
+ List<QProfileDto> customProfiles = new ArrayList<>();
+ Set<String> rulesProfileUuidsOfCustomProfiles = new HashSet<>();
+ profiles.forEach(p -> {
+ uuids.add(p.getKee());
+ if (!p.isBuiltIn()) {
+ customProfiles.add(p);
+ rulesProfileUuidsOfCustomProfiles.add(p.getRulesProfileUuid());
+ }
+ });
+
+ // tables org_qprofiles, default_qprofiles and project_qprofiles
+ // are deleted whatever custom or built-in
+ db.qualityProfileDao().deleteProjectAssociationsByProfileUuids(dbSession, uuids);
+ db.defaultQProfileDao().deleteByQProfileUuids(dbSession, uuids);
+ db.qualityProfileDao().deleteOrgQProfilesByUuids(dbSession, uuids);
+
+ // tables related to rules_profiles and active_rules are deleted
+ // only for custom profiles
+ if (!rulesProfileUuidsOfCustomProfiles.isEmpty()) {
+ db.activeRuleDao().deleteParametersByRuleProfileUuids(dbSession, rulesProfileUuidsOfCustomProfiles);
+ db.activeRuleDao().deleteByRuleProfileUuids(dbSession, rulesProfileUuidsOfCustomProfiles);
+ db.qProfileChangeDao().deleteByRulesProfileUuids(dbSession, rulesProfileUuidsOfCustomProfiles);
+ db.qualityProfileDao().deleteRulesProfilesByUuids(dbSession, rulesProfileUuidsOfCustomProfiles);
+ }
+ dbSession.commit();
+ activeRuleIndexer.deleteByProfiles(customProfiles);
+ }
}
}
public List<QProfileDto> allProfiles(DbSession dbSession, OrganizationDto organization) {
- return db.qualityProfileDao().selectAll(dbSession, organization);
+ return db.qualityProfileDao().selectOrderedByOrganizationUuid(dbSession, organization);
}
public Collection<QProfileDto> profiles(DbSession dbSession, String language, OrganizationDto organization) {
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import org.sonar.db.qualityprofile.ActiveRuleDto;
-import org.sonar.db.qualityprofile.ActiveRuleKey;
import org.sonar.db.qualityprofile.QProfileDto;
import org.sonar.server.exceptions.BadRequestException;
import org.sonar.server.qualityprofile.index.ActiveRuleIndexer;
BulkChangeResult result = new BulkChangeResult();
Set<RuleKey> ruleToBeDeactivated = Sets.newHashSet();
// Keep reference to all the activated rules before backup restore
- for (ActiveRuleDto activeRuleDto : db.activeRuleDao().selectByProfileKey(dbSession, profile.getKee())) {
+ for (ActiveRuleDto activeRuleDto : db.activeRuleDao().selectByProfile(dbSession, profile)) {
if (activeRuleDto.getInheritance() == null) {
// inherited rules can't be deactivated
- ruleToBeDeactivated.add(activeRuleDto.getKey().ruleKey());
+ ruleToBeDeactivated.add(activeRuleDto.getRuleKey());
}
}
for (RuleActivation activation : activations) {
try {
- List<ActiveRuleChange> changes = activator.activate(dbSession, activation, profile.getKee());
+ List<ActiveRuleChange> changes = activator.activate(dbSession, activation, profile);
ruleToBeDeactivated.remove(activation.getRuleKey());
result.incrementSucceeded();
result.addChanges(changes);
changes.addAll(result.getChanges());
for (RuleKey ruleKey : ruleToBeDeactivated) {
try {
- changes.addAll(activator.deactivate(dbSession, ActiveRuleKey.of(profile.getKee(), ruleKey)));
+ changes.addAll(activator.deactivate(dbSession, profile, ruleKey));
} catch (BadRequestException e) {
// ignore, probably a rule inherited from parent that can't be deactivated
}
}
dbSession.commit();
- activeRuleIndexer.index(changes);
+ activeRuleIndexer.indexChanges(dbSession, changes);
return result;
}
import java.util.Collection;
import java.util.List;
+import java.util.Set;
import org.sonar.api.server.ServerSide;
import org.sonar.api.utils.log.Logger;
import org.sonar.api.utils.log.Loggers;
import org.sonar.api.utils.log.Profiler;
+import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
-import org.sonar.db.organization.OrganizationDto;
-import org.sonar.server.qualityprofile.index.ActiveRuleIndexer;
import static java.lang.String.format;
private final BuiltInQProfileRepository builtInQProfileRepository;
private final DbClient dbClient;
private final BuiltInQProfileInsert builtInQProfileInsert;
- private final ActiveRuleIndexer activeRuleIndexer;
public RegisterQualityProfiles(BuiltInQProfileRepository builtInQProfileRepository,
- DbClient dbClient, BuiltInQProfileInsert builtInQProfileInsert, ActiveRuleIndexer activeRuleIndexer) {
+ DbClient dbClient, BuiltInQProfileInsert builtInQProfileInsert) {
this.builtInQProfileRepository = builtInQProfileRepository;
this.dbClient = dbClient;
this.builtInQProfileInsert = builtInQProfileInsert;
- this.activeRuleIndexer = activeRuleIndexer;
}
public void start() {
- Profiler profiler = Profiler.create(Loggers.get(getClass())).startInfo("Register quality profiles");
- if (builtInQProfileRepository.getQProfilesByLanguage().isEmpty()) {
+ List<BuiltInQProfile> builtInQProfiles = builtInQProfileRepository.get();
+ if (builtInQProfiles.isEmpty()) {
return;
}
- try (DbSession session = dbClient.openSession(false);
- DbSession batchSession = dbClient.openSession(true)) {
- builtInQProfileRepository.getQProfilesByLanguage()
- .forEach((key, value) -> registerPerLanguage(session, batchSession, value));
- activeRuleIndexer.index();
- profiler.stopDebug();
- }
- }
+ Profiler profiler = Profiler.create(Loggers.get(getClass())).startInfo("Register quality profiles");
+ try (DbSession dbSession = dbClient.openSession(false);
+ DbSession batchDbSession = dbClient.openSession(true)) {
+
+ Set<QProfileName> namesExistingInDb = dbClient.qualityProfileDao().selectBuiltInRulesProfiles(dbSession).stream()
+ .map(dto -> new QProfileName(dto.getLanguage(), dto.getName()))
+ .collect(MoreCollectors.toSet());
- private void registerPerLanguage(DbSession session, DbSession batchSession, List<BuiltInQProfile> qualityProfiles) {
- qualityProfiles.forEach(qp -> registerPerQualityProfile(session, batchSession, qp));
+ builtInQProfiles.stream()
+ .filter(p -> !namesExistingInDb.contains(p.getQProfileName()))
+ .forEach(profile -> register(dbSession, batchDbSession, profile));
+ }
+ profiler.stopDebug();
}
- private void registerPerQualityProfile(DbSession dbSession, DbSession batchSession, BuiltInQProfile builtInProfile) {
+ private void register(DbSession dbSession, DbSession batchDbSession, BuiltInQProfile builtInProfile) {
LOGGER.info("Register profile {}", builtInProfile.getQProfileName());
- Profiler profiler = Profiler.create(Loggers.get(getClass()));
renameOutdatedProfiles(dbSession, builtInProfile);
- dbClient.organizationDao().selectWithoutQualityProfile(dbSession, builtInProfile.getLanguage(), builtInProfile.getName()).forEach(
- organization -> registerProfileOnOrganization(dbSession, batchSession, builtInProfile, organization, profiler));
- }
-
- private void registerProfileOnOrganization(DbSession session, DbSession batchSession,
- BuiltInQProfile builtInQProfile, OrganizationDto organization, Profiler profiler) {
- profiler.start();
-
- builtInQProfileInsert.create(session, batchSession, builtInQProfile, organization);
-
- session.commit();
- batchSession.commit();
-
- profiler.stopDebug(format("Register profile %s for organization %s", builtInQProfile.getQProfileName(), organization.getKey()));
+ builtInQProfileInsert.create(dbSession, batchDbSession, builtInProfile);
}
/**
if (uuids.isEmpty()) {
return;
}
+ Profiler profiler = Profiler.createIfDebug(Loggers.get(getClass())).start();
String newName = profile.getName() + " (outdated copy)";
LOGGER.info("Rename Quality profiles [{}/{}] to [{}] in {}Â organizations", profile.getLanguage(), profile.getName(), newName, uuids.size());
dbClient.qualityProfileDao().renameRulesProfilesAndCommit(dbSession, uuids, newName);
+ profiler.stopDebug(format("%d Quality profiles renamed to [%s]", uuids.size(), newName));
}
}
import org.sonar.db.DbSession;
import org.sonar.db.qualityprofile.ActiveRuleDao;
import org.sonar.db.qualityprofile.ActiveRuleDto;
-import org.sonar.db.qualityprofile.ActiveRuleKey;
import org.sonar.db.qualityprofile.ActiveRuleParamDto;
import org.sonar.db.qualityprofile.QProfileDto;
import org.sonar.db.rule.RuleDefinitionDto;
this.userSession = userSession;
}
- public List<ActiveRuleChange> activate(DbSession dbSession, RuleActivation activation, String profileKey) {
- RuleActivatorContext context = contextFactory.create(profileKey, activation.getRuleKey(), dbSession);
- return doActivate(dbSession, activation, context);
- }
-
public List<ActiveRuleChange> activate(DbSession dbSession, RuleActivation activation, QProfileDto profileDto) {
RuleActivatorContext context = contextFactory.create(profileDto, activation.getRuleKey(), dbSession);
return doActivate(dbSession, activation, context);
return changes;
}
// new activation
- change = ActiveRuleChange.createFor(ActiveRuleChange.Type.ACTIVATED, context.activeRuleKey());
+ change = new ActiveRuleChange(ActiveRuleChange.Type.ACTIVATED, context.activeRuleKey());
applySeverityAndParamToChange(activation, context, change);
if (activation.isCascade() || context.isSameAsParent(change)) {
change.setInheritance(ActiveRule.Inheritance.INHERITED);
// propagating to descendants, but child profile already overrides rule -> stop propagation
return changes;
}
- change = ActiveRuleChange.createFor(ActiveRuleChange.Type.UPDATED, context.activeRuleKey());
+ change = new ActiveRuleChange(ActiveRuleChange.Type.UPDATED, context.activeRuleKey());
if (activation.isCascade() && activeRule.getInheritance() == null) {
// activate on child, then on parent -> mark child as overriding parent
change.setInheritance(ActiveRule.Inheritance.OVERRIDES);
return null;
}
- private List<ActiveRuleChange> cascadeActivation(DbSession session, RuleActivation activation, QProfileDto qProfileDto) {
- List<ActiveRuleChange> changes = Lists.newArrayList();
+ private List<ActiveRuleChange> cascadeActivation(DbSession dbSession, RuleActivation activation, QProfileDto profile) {
+ List<ActiveRuleChange> changes = new ArrayList<>();
// get all inherited profiles
- String qualityProfileKey = qProfileDto.getKee();
- List<QProfileDto> children = getChildren(session, qualityProfileKey);
- for (QProfileDto child : children) {
+ getChildren(dbSession, profile).forEach(child -> {
RuleActivation childActivation = new RuleActivation(activation).setCascade(true);
- changes.addAll(activate(session, childActivation, child));
- }
+ changes.addAll(activate(dbSession, childActivation, child));
+ });
return changes;
}
- protected List<QProfileDto> getChildren(DbSession session, String qualityProfileKey) {
- return db.qualityProfileDao().selectChildren(session, qualityProfileKey);
+ protected List<QProfileDto> getChildren(DbSession session, QProfileDto profile) {
+ return db.qualityProfileDao().selectChildren(session, profile);
}
private ActiveRuleDto persist(ActiveRuleChange change, RuleActivatorContext context, DbSession dbSession) {
activeRule = doInsert(change, context, dbSession);
} else if (change.getType() == ActiveRuleChange.Type.DEACTIVATED) {
ActiveRuleDao dao = db.activeRuleDao();
- dao.delete(dbSession, change.getKey());
+ activeRule = dao.delete(dbSession, change.getKey()).orElse(null);
} else if (change.getType() == ActiveRuleChange.Type.UPDATED) {
activeRule = doUpdate(change, context, dbSession);
}
-
+ change.setActiveRule(activeRule);
db.qProfileChangeDao().insert(dbSession, change.toDto(userSession.getLogin()));
return activeRule;
}
} else {
if (param.getValue() != null) {
activeRuleParamDto.setValue(param.getValue());
- dao.updateParam(dbSession, activeRule, activeRuleParamDto);
+ dao.updateParam(dbSession, activeRuleParamDto);
} else {
- dao.deleteParam(dbSession, activeRule, activeRuleParamDto);
+ dao.deleteParam(dbSession, activeRuleParamDto);
}
}
}
* Deactivate a rule on a Quality profile. Does nothing if the rule is not activated, but
* fails (fast) if the rule or the profile does not exist.
*/
- public List<ActiveRuleChange> deactivateAndUpdateIndex(DbSession dbSession, ActiveRuleKey key) {
- List<ActiveRuleChange> changes = deactivate(dbSession, key);
+ public void deactivateAndUpdateIndex(DbSession dbSession, QProfileDto profile, RuleKey ruleKey) {
+ List<ActiveRuleChange> changes = deactivate(dbSession, profile, ruleKey);
dbSession.commit();
- activeRuleIndexer.index(changes);
- return changes;
+ activeRuleIndexer.indexChanges(dbSession, changes);
}
/**
* Deactivate a rule on a Quality profile WITHOUT committing db session and WITHOUT checking permissions
*/
- List<ActiveRuleChange> deactivate(DbSession dbSession, ActiveRuleKey key) {
- return deactivate(dbSession, key, false);
+ List<ActiveRuleChange> deactivate(DbSession dbSession, QProfileDto profile, RuleKey ruleKey) {
+ return deactivate(dbSession, profile, ruleKey, false);
}
/**
* Deactivate a rule on a Quality profile WITHOUT committing db session, WITHOUT checking permissions, and forcing removal of inherited rules
*/
- public List<ActiveRuleChange> deactivateOfAllOrganizations(DbSession dbSession, RuleDefinitionDto ruleDto) {
- List<ActiveRuleChange> changes = Lists.newArrayList();
- List<ActiveRuleDto> activeRules = db.activeRuleDao().selectByRuleIdOfAllOrganizations(dbSession, ruleDto.getId());
+ public List<ActiveRuleChange> deactivateOfAllOrganizations(DbSession dbSession, RuleDefinitionDto rule) {
+ List<ActiveRuleChange> changes = new ArrayList<>();
+ List<ActiveRuleDto> activeRules = db.activeRuleDao().selectByRuleIdOfAllOrganizations(dbSession, rule.getId());
for (ActiveRuleDto activeRule : activeRules) {
- changes.addAll(deactivate(dbSession, activeRule.getKey(), true));
+ // FIXME changes.addAll(deactivate(dbSession, activeRule.getKey(), rule.getKey(), true));
}
return changes;
}
/**
* @param force if true then inherited rules are deactivated
*/
- public List<ActiveRuleChange> deactivate(DbSession dbSession, ActiveRuleKey key, boolean force) {
- return cascadeDeactivation(key, dbSession, false, force);
+ public List<ActiveRuleChange> deactivate(DbSession dbSession, QProfileDto profile, RuleKey ruleKey, boolean force) {
+ return cascadeDeactivation(dbSession, profile, ruleKey, false, force);
}
- private List<ActiveRuleChange> cascadeDeactivation(ActiveRuleKey key, DbSession dbSession, boolean isCascade, boolean force) {
- List<ActiveRuleChange> changes = Lists.newArrayList();
- RuleActivatorContext context = contextFactory.create(key.qProfile(), key.ruleKey(), dbSession);
+ private List<ActiveRuleChange> cascadeDeactivation(DbSession dbSession, QProfileDto profile, RuleKey ruleKey, boolean isCascade, boolean force) {
+ List<ActiveRuleChange> changes = new ArrayList<>();
+ RuleActivatorContext context = contextFactory.create(profile, ruleKey, dbSession);
ActiveRuleChange change;
ActiveRuleDto activeRuleDto = context.activeRule();
if (activeRuleDto == null) {
return changes;
}
- checkRequest(force || isCascade || activeRuleDto.getInheritance() == null, "Cannot deactivate inherited rule '%s'", key.ruleKey());
- change = ActiveRuleChange.createFor(ActiveRuleChange.Type.DEACTIVATED, key);
+ checkRequest(force || isCascade || activeRuleDto.getInheritance() == null, "Cannot deactivate inherited rule '%s'", ruleKey);
+ change = new ActiveRuleChange(ActiveRuleChange.Type.DEACTIVATED, activeRuleDto);
changes.add(change);
persist(change, context, dbSession);
// get all inherited profiles
- List<QProfileDto> profiles = getChildren(dbSession, key.qProfile());
- for (QProfileDto profile : profiles) {
- ActiveRuleKey activeRuleKey = ActiveRuleKey.of(profile.getKee(), key.ruleKey());
- changes.addAll(cascadeDeactivation(activeRuleKey, dbSession, true, force));
- }
+ getChildren(dbSession, profile).forEach(child -> changes.addAll(cascadeDeactivation(dbSession, child, ruleKey, true, force)));
if (!changes.isEmpty()) {
updateProfileDates(dbSession, context);
return value;
}
- public BulkChangeResult bulkActivate(RuleQuery ruleQuery, String profileKey, @Nullable String severity) {
- DbSession dbSession = db.openSession(false);
+ public BulkChangeResult bulkActivate(DbSession dbSession, RuleQuery ruleQuery, QProfileDto profile, @Nullable String severity) {
BulkChangeResult result = new BulkChangeResult();
- try {
- Iterator<RuleKey> rules = ruleIndex.searchAll(ruleQuery);
- while (rules.hasNext()) {
- RuleKey ruleKey = rules.next();
- try {
- RuleActivation activation = new RuleActivation(ruleKey);
- activation.setSeverity(severity);
- List<ActiveRuleChange> changes = activate(dbSession, activation, profileKey);
- result.addChanges(changes);
- if (!changes.isEmpty()) {
- result.incrementSucceeded();
- }
-
- } catch (BadRequestException e) {
- // other exceptions stop the bulk activation
- result.incrementFailed();
- result.getErrors().addAll(e.errors());
+ Iterator<RuleKey> rules = ruleIndex.searchAll(ruleQuery);
+ while (rules.hasNext()) {
+ RuleKey ruleKey = rules.next();
+ try {
+ RuleActivation activation = new RuleActivation(ruleKey);
+ activation.setSeverity(severity);
+ List<ActiveRuleChange> changes = activate(dbSession, activation, profile);
+ result.addChanges(changes);
+ if (!changes.isEmpty()) {
+ result.incrementSucceeded();
}
+
+ } catch (BadRequestException e) {
+ // other exceptions stop the bulk activation
+ result.incrementFailed();
+ result.getErrors().addAll(e.errors());
}
- dbSession.commit();
- activeRuleIndexer.index(result.getChanges());
- } finally {
- dbSession.close();
}
+ dbSession.commit();
+ activeRuleIndexer.indexChanges(dbSession, result.getChanges());
return result;
}
- public BulkChangeResult bulkDeactivate(RuleQuery ruleQuery, String profile) {
- DbSession dbSession = db.openSession(false);
+ public BulkChangeResult bulkDeactivate(DbSession dbSession, RuleQuery ruleQuery, QProfileDto profile) {
BulkChangeResult result = new BulkChangeResult();
- try {
- Iterator<RuleKey> rules = ruleIndex.searchAll(ruleQuery);
- while (rules.hasNext()) {
- try {
- RuleKey ruleKey = rules.next();
- ActiveRuleKey key = ActiveRuleKey.of(profile, ruleKey);
- List<ActiveRuleChange> changes = deactivate(dbSession, key);
- result.addChanges(changes);
- if (!changes.isEmpty()) {
- result.incrementSucceeded();
- }
- } catch (BadRequestException e) {
- // other exceptions stop the bulk activation
- result.incrementFailed();
- result.getErrors().addAll(e.errors());
+ Iterator<RuleKey> rules = ruleIndex.searchAll(ruleQuery);
+ while (rules.hasNext()) {
+ try {
+ RuleKey ruleKey = rules.next();
+ List<ActiveRuleChange> changes = deactivate(dbSession, profile, ruleKey);
+ result.addChanges(changes);
+ if (!changes.isEmpty()) {
+ result.incrementSucceeded();
}
+ } catch (BadRequestException e) {
+ // other exceptions stop the bulk activation
+ result.incrementFailed();
+ result.getErrors().addAll(e.errors());
}
- dbSession.commit();
- activeRuleIndexer.index(result.getChanges());
- return result;
- } finally {
- dbSession.close();
}
+ dbSession.commit();
+ activeRuleIndexer.indexChanges(dbSession, result.getChanges());
+ return result;
}
- public List<ActiveRuleChange> setParent(DbSession dbSession, String profileKey, @Nullable String parentKey) {
- QProfileDto profile = db.qualityProfileDao().selectOrFailByUuid(dbSession, profileKey);
+ public List<ActiveRuleChange> setParent(DbSession dbSession, QProfileDto profile, @Nullable QProfileDto parent) {
List<ActiveRuleChange> changes = new ArrayList<>();
- if (parentKey == null) {
+ if (parent == null) {
// unset if parent is defined, else nothing to do
changes.addAll(removeParent(dbSession, profile));
- } else if (profile.getParentKee() == null || !parentKey.equals(profile.getParentKee())) {
- QProfileDto parentProfile = db.qualityProfileDao().selectOrFailByUuid(dbSession, parentKey);
- checkRequest(!isDescendant(dbSession, profile, parentProfile), "Descendant profile '%s' can not be selected as parent of '%s'", parentKey, profileKey);
+ } else if (profile.getParentKee() == null || !parent.getKee().equals(profile.getParentKee())) {
+ checkRequest(!isDescendant(dbSession, profile, parent), "Descendant profile '%s' can not be selected as parent of '%s'", parent.getKee(), profile.getKee());
changes.addAll(removeParent(dbSession, profile));
// set new parent
- profile.setParentKee(parentKey);
+ profile.setParentKee(parent.getKee());
db.qualityProfileDao().update(dbSession, profile);
- for (ActiveRuleDto parentActiveRule : db.activeRuleDao().selectByProfileKey(dbSession, parentKey)) {
+ for (ActiveRuleDto parentActiveRule : db.activeRuleDao().selectByProfile(dbSession, parent)) {
try {
- RuleActivation activation = new RuleActivation(parentActiveRule.getKey().ruleKey());
- changes.addAll(activate(dbSession, activation, profileKey));
+ RuleActivation activation = new RuleActivation(parentActiveRule.getRuleKey());
+ changes.addAll(activate(dbSession, activation, profile));
} catch (BadRequestException e) {
// for example because rule status is REMOVED
// TODO return errors
}
}
dbSession.commit();
- activeRuleIndexer.index(changes);
+ activeRuleIndexer.indexChanges(dbSession, changes);
return changes;
}
/**
* Does not commit
*/
- private List<ActiveRuleChange> removeParent(DbSession dbSession, QProfileDto profileDto) {
- if (profileDto.getParentKee() != null) {
+ private List<ActiveRuleChange> removeParent(DbSession dbSession, QProfileDto profile) {
+ if (profile.getParentKee() != null) {
List<ActiveRuleChange> changes = new ArrayList<>();
- profileDto.setParentKee(null);
- db.qualityProfileDao().update(dbSession, profileDto);
- for (ActiveRuleDto activeRule : db.activeRuleDao().selectByProfileKey(dbSession, profileDto.getKee())) {
+ profile.setParentKee(null);
+ db.qualityProfileDao().update(dbSession, profile);
+ for (ActiveRuleDto activeRule : db.activeRuleDao().selectByProfile(dbSession, profile)) {
if (ActiveRuleDto.INHERITED.equals(activeRule.getInheritance())) {
- changes.addAll(deactivate(dbSession, activeRule.getKey(), true));
+ changes.addAll(deactivate(dbSession, profile, activeRule.getRuleKey(), true));
} else if (ActiveRuleDto.OVERRIDES.equals(activeRule.getInheritance())) {
activeRule.setInheritance(null);
activeRule.setUpdatedAt(system2.now());
db.activeRuleDao().update(dbSession, activeRule);
- changes.add(ActiveRuleChange.createFor(ActiveRuleChange.Type.UPDATED, activeRule.getKey()).setInheritance(null));
+ changes.add(new ActiveRuleChange(ActiveRuleChange.Type.UPDATED, activeRule).setInheritance(null));
}
}
return changes;
return Collections.emptyList();
}
- boolean isDescendant(DbSession dbSession, QProfileDto childProfile, @Nullable QProfileDto parentProfile) {
+ private boolean isDescendant(DbSession dbSession, QProfileDto childProfile, @Nullable QProfileDto parentProfile) {
QProfileDto currentParent = parentProfile;
while (currentParent != null) {
if (childProfile.getName().equals(currentParent.getName())) {
}
ActiveRuleKey activeRuleKey() {
- return ActiveRuleKey.of(profile.getKee(), rule.getKey());
+ return ActiveRuleKey.of(profile, rule.getKey());
}
RuleDefinitionDto rule() {
this.db = db;
}
- RuleActivatorContext create(String profileKey, RuleKey ruleKey, DbSession session) {
- RuleActivatorContext context = new RuleActivatorContext();
- QProfileDto profile = getQualityProfileDto(session, profileKey);
- checkRequest(profile != null, "Quality profile not found: %s", profileKey);
- context.setProfile(profile);
- return create(ruleKey, session, context);
- }
-
RuleActivatorContext create(QProfileDto profile, RuleKey ruleKey, DbSession session) {
return create(ruleKey, session, new RuleActivatorContext().setProfile(profile));
}
- private RuleActivatorContext create(RuleKey ruleKey, DbSession session, RuleActivatorContext context) {
- initRule(ruleKey, context, session);
- initActiveRules(context.profile().getKee(), ruleKey, context, session, false);
+ private RuleActivatorContext create(RuleKey ruleKey, DbSession dbSession, RuleActivatorContext context) {
+ initRule(ruleKey, context, dbSession);
+ initActiveRules(context.profile(), ruleKey, context, dbSession, false);
String parentKee = context.profile().getParentKee();
if (parentKee != null) {
- initActiveRules(parentKee, ruleKey, context, session, true);
+ QProfileDto parent = getQualityProfileDto(dbSession, parentKee);
+ initActiveRules(parent, ruleKey, context, dbSession, true);
}
return context;
}
return ruleDefinitionDto;
}
- private void initActiveRules(String profileKey, RuleKey ruleKey, RuleActivatorContext context, DbSession session, boolean parent) {
- ActiveRuleKey key = ActiveRuleKey.of(profileKey, ruleKey);
+ private void initActiveRules(QProfileDto profile, RuleKey ruleKey, RuleActivatorContext context, DbSession session, boolean parent) {
+ ActiveRuleKey key = ActiveRuleKey.of(profile, ruleKey);
Optional<ActiveRuleDto> activeRule = getActiveRule(session, key);
Collection<ActiveRuleParamDto> activeRuleParams = null;
if (activeRule.isPresent()) {
return db.ruleDao().selectRuleParamsByRuleKey(dbSession, ruleDefinitionDto.getKey());
}
- Optional<ActiveRuleDto> getActiveRule(DbSession session, ActiveRuleKey key) {
- return Optional.ofNullable(db.activeRuleDao().selectByKey(session, key).orNull());
+ Optional<ActiveRuleDto> getActiveRule(DbSession dbSession, ActiveRuleKey key) {
+ return db.activeRuleDao().selectByKey(dbSession, key);
}
- List<ActiveRuleParamDto> getActiveRuleParams(DbSession session, ActiveRuleDto activeRuleDto) {
- return db.activeRuleDao().selectParamsByActiveRuleId(session, activeRuleDto.getId());
+ List<ActiveRuleParamDto> getActiveRuleParams(DbSession dbSession, ActiveRuleDto activeRuleDto) {
+ return db.activeRuleDao().selectParamsByActiveRuleId(dbSession, activeRuleDto.getId());
}
}
package org.sonar.server.qualityprofile.index;
import com.google.common.collect.Maps;
+import java.util.Map;
import javax.annotation.Nullable;
-import org.sonar.db.qualityprofile.ActiveRuleKey;
+import org.sonar.api.rule.RuleKey;
import org.sonar.server.es.BaseDoc;
import org.sonar.server.qualityprofile.ActiveRule;
-import static com.google.common.base.Preconditions.checkNotNull;
import static org.apache.commons.lang.StringUtils.containsIgnoreCase;
import static org.sonar.server.rule.index.RuleIndexDefinition.FIELD_ACTIVE_RULE_INHERITANCE;
-import static org.sonar.server.rule.index.RuleIndexDefinition.FIELD_ACTIVE_RULE_KEY;
-import static org.sonar.server.rule.index.RuleIndexDefinition.FIELD_ACTIVE_RULE_ORGANIZATION_UUID;
-import static org.sonar.server.rule.index.RuleIndexDefinition.FIELD_ACTIVE_RULE_PROFILE_KEY;
+import static org.sonar.server.rule.index.RuleIndexDefinition.FIELD_ACTIVE_RULE_PROFILE_UUID;
import static org.sonar.server.rule.index.RuleIndexDefinition.FIELD_ACTIVE_RULE_REPOSITORY;
import static org.sonar.server.rule.index.RuleIndexDefinition.FIELD_ACTIVE_RULE_RULE_KEY;
import static org.sonar.server.rule.index.RuleIndexDefinition.FIELD_ACTIVE_RULE_SEVERITY;
-import static org.sonar.server.rule.index.RuleIndexDefinition.FIELD_ACTIVE_RULE_UPDATED_AT;
public class ActiveRuleDoc extends BaseDoc {
- private final ActiveRuleKey key;
-
- public ActiveRuleDoc(ActiveRuleKey key) {
+ public ActiveRuleDoc(String id) {
super(Maps.newHashMapWithExpectedSize(9));
- checkNotNull(key, "ActiveRuleKey cannot be null");
- this.key = key;
- setField(FIELD_ACTIVE_RULE_KEY, key.toString());
- setField(FIELD_ACTIVE_RULE_PROFILE_KEY, key.qProfile());
- setField(FIELD_ACTIVE_RULE_RULE_KEY, key.ruleKey().toString());
- setField(FIELD_ACTIVE_RULE_REPOSITORY, key.ruleKey().repository());
+ setField("_id", id);
+ }
+
+ public ActiveRuleDoc(Map<String,Object> source) {
+ super(source);
}
@Override
public String getId() {
- return key().toString();
+ return getField("_id");
}
@Override
@Override
public String getParent() {
- return key.ruleKey().toString();
+ return getRuleKey().toString();
}
- public ActiveRuleKey key() {
- return key;
+ RuleKey getRuleKey() {
+ return RuleKey.parse(getField(FIELD_ACTIVE_RULE_RULE_KEY));
}
- String organizationUuid() {
- return getField(FIELD_ACTIVE_RULE_ORGANIZATION_UUID);
+ String getRuleRepository() {
+ return getField(FIELD_ACTIVE_RULE_REPOSITORY);
}
- public ActiveRuleDoc setOrganizationUuid(String s) {
- setField(FIELD_ACTIVE_RULE_ORGANIZATION_UUID, s);
+ String getSeverity() {
+ return getNullableField(FIELD_ACTIVE_RULE_SEVERITY);
+ }
+
+ ActiveRuleDoc setSeverity(@Nullable String s) {
+ setField(FIELD_ACTIVE_RULE_SEVERITY, s);
return this;
}
- String severity() {
- return getNullableField(FIELD_ACTIVE_RULE_SEVERITY);
+ ActiveRuleDoc setRuleKey(RuleKey ruleKey) {
+ setField(FIELD_ACTIVE_RULE_RULE_KEY, ruleKey.toString());
+ setField(FIELD_ACTIVE_RULE_REPOSITORY, ruleKey.repository());
+ return this;
}
- public ActiveRuleDoc setSeverity(@Nullable String s) {
- setField(FIELD_ACTIVE_RULE_SEVERITY, s);
+ String getRuleProfileUuid() {
+ return getField(FIELD_ACTIVE_RULE_PROFILE_UUID);
+ }
+
+ ActiveRuleDoc setRuleProfileUuid(String s) {
+ setField(FIELD_ACTIVE_RULE_PROFILE_UUID, s);
return this;
}
- ActiveRule.Inheritance inheritance() {
+ ActiveRule.Inheritance getInheritance() {
String inheritance = getNullableField(FIELD_ACTIVE_RULE_INHERITANCE);
if (inheritance == null || inheritance.isEmpty() ||
containsIgnoreCase(inheritance, "none")) {
setField(FIELD_ACTIVE_RULE_INHERITANCE, s);
return this;
}
-
- long updatedAt() {
- return (Long) getField(FIELD_ACTIVE_RULE_UPDATED_AT);
- }
-
- public ActiveRuleDoc setUpdatedAt(@Nullable Long l) {
- setField(FIELD_ACTIVE_RULE_UPDATED_AT, l);
- return this;
- }
}
*/
package org.sonar.server.qualityprofile.index;
+import com.google.common.collect.ImmutableSet;
+import java.util.ArrayList;
import java.util.Collection;
-import java.util.Iterator;
import java.util.List;
+import java.util.Set;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.search.SearchRequestBuilder;
import org.elasticsearch.index.query.QueryBuilders;
-import org.sonar.api.utils.System2;
-import org.sonar.core.util.stream.MoreCollectors;
+import org.sonar.api.rule.RuleKey;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
-import org.sonar.db.qualityprofile.ActiveRuleKey;
-import org.sonar.server.es.BaseIndexer;
+import org.sonar.db.qualityprofile.QProfileDto;
+import org.sonar.db.qualityprofile.RulesProfileDto;
import org.sonar.server.es.BulkIndexer;
import org.sonar.server.es.BulkIndexer.Size;
import org.sonar.server.es.EsClient;
+import org.sonar.server.es.IndexType;
+import org.sonar.server.es.StartupIndexer;
import org.sonar.server.qualityprofile.ActiveRuleChange;
+import org.sonar.server.rule.index.RuleIndexDefinition;
-import static org.elasticsearch.index.query.QueryBuilders.termsQuery;
-import static org.sonar.server.rule.index.RuleIndexDefinition.FIELD_ACTIVE_RULE_KEY;
-import static org.sonar.server.rule.index.RuleIndexDefinition.FIELD_ACTIVE_RULE_PROFILE_KEY;
-import static org.sonar.server.rule.index.RuleIndexDefinition.FIELD_ACTIVE_RULE_UPDATED_AT;
+import static org.elasticsearch.index.query.QueryBuilders.termQuery;
+import static org.sonar.server.rule.index.RuleIndexDefinition.FIELD_ACTIVE_RULE_PROFILE_UUID;
+import static org.sonar.server.rule.index.RuleIndexDefinition.FIELD_ACTIVE_RULE_RULE_KEY;
import static org.sonar.server.rule.index.RuleIndexDefinition.INDEX_TYPE_ACTIVE_RULE;
-public class ActiveRuleIndexer extends BaseIndexer {
+public class ActiveRuleIndexer implements StartupIndexer {
private final DbClient dbClient;
+ private final EsClient esClient;
+ private final ActiveRuleIteratorFactory activeRuleIteratorFactory;
- public ActiveRuleIndexer(System2 system2, DbClient dbClient, EsClient esClient) {
- super(system2, esClient, 300, INDEX_TYPE_ACTIVE_RULE, FIELD_ACTIVE_RULE_UPDATED_AT);
+ public ActiveRuleIndexer(DbClient dbClient, EsClient esClient, ActiveRuleIteratorFactory activeRuleIteratorFactory) {
this.dbClient = dbClient;
+ this.esClient = esClient;
+ this.activeRuleIteratorFactory = activeRuleIteratorFactory;
}
@Override
- protected long doIndex(long lastUpdatedAt) {
- return doIndex(createBulkIndexer(), lastUpdatedAt);
+ public void indexOnStartup(Set<IndexType> emptyIndexTypes) {
+ try (DbSession dbSession = dbClient.openSession(false)) {
+ ActiveRuleIterator dbCursor = activeRuleIteratorFactory.createForAll(dbSession);
+ scrollDbAndIndex(dbCursor, Size.LARGE);
+ }
}
- public void index(Iterator<ActiveRuleDoc> rules) {
- doIndex(createBulkIndexer(), rules);
+ @Override
+ public Set<IndexType> getIndexTypes() {
+ return ImmutableSet.of(RuleIndexDefinition.INDEX_TYPE_ACTIVE_RULE);
}
- private long doIndex(BulkIndexer bulk, long lastUpdatedAt) {
- long maxDate;
- try (DbSession dbSession = dbClient.openSession(false)) {
- ActiveRuleResultSetIterator rowIt = ActiveRuleResultSetIterator.create(dbClient, dbSession, lastUpdatedAt);
- maxDate = doIndex(bulk, rowIt);
- rowIt.close();
- return maxDate;
+ /**
+ * Important - the existing documents are not deleted, so this method
+ * does not guarantee consistency of index.
+ */
+ public void indexRuleProfile(DbSession dbSession, RulesProfileDto ruleProfile) {
+ try (ActiveRuleIterator dbCursor = activeRuleIteratorFactory.createForRuleProfile(dbSession, ruleProfile)) {
+ scrollDbAndIndex(dbCursor, Size.REGULAR);
}
}
- private static long doIndex(BulkIndexer bulk, Iterator<ActiveRuleDoc> activeRules) {
+ public void indexChanges(DbSession dbSession, List<ActiveRuleChange> changes) {
+ BulkIndexer bulk = createBulkIndexer(Size.REGULAR);
bulk.start();
- long maxDate = 0L;
- while (activeRules.hasNext()) {
- ActiveRuleDoc activeRule = activeRules.next();
- bulk.add(newIndexRequest(activeRule));
-
- // it's more efficient to sort programmatically than in SQL on some databases (MySQL for instance)
- maxDate = Math.max(maxDate, activeRule.updatedAt());
+ List<Integer> idsOfTouchedActiveRules = new ArrayList<>();
+ changes.stream()
+ .filter(c -> c.getActiveRule() != null)
+ .forEach(c -> {
+ if (c.getType().equals(ActiveRuleChange.Type.DEACTIVATED)) {
+ bulk.addDeletion(INDEX_TYPE_ACTIVE_RULE, String.valueOf(c.getActiveRule().getId()));
+ } else {
+ idsOfTouchedActiveRules.add(c.getActiveRule().getId());
+ }
+ });
+ try (ActiveRuleIterator dbCursor = activeRuleIteratorFactory.createForActiveRules(dbSession, idsOfTouchedActiveRules)) {
+ while (dbCursor.hasNext()) {
+ ActiveRuleDoc activeRule = dbCursor.next();
+ bulk.add(newIndexRequest(activeRule));
+ }
}
bulk.stop();
- return maxDate;
- }
-
- public void index(List<ActiveRuleChange> changes) {
- deleteKeys(changes.stream()
- .filter(c -> c.getType().equals(ActiveRuleChange.Type.DEACTIVATED))
- .map(ActiveRuleChange::getKey)
- .collect(MoreCollectors.toList(changes.size())));
-
- index();
}
- public void deleteByProfileKeys(Collection<String> profileKeys) {
- BulkIndexer bulk = createBulkIndexer();
+ public void deleteByProfiles(Collection<QProfileDto> profiles) {
+ BulkIndexer bulk = createBulkIndexer(Size.REGULAR);
bulk.start();
- profileKeys.forEach(profileKey -> {
+ profiles.forEach(profile -> {
SearchRequestBuilder search = esClient.prepareSearch(INDEX_TYPE_ACTIVE_RULE)
- .setQuery(QueryBuilders.boolQuery().must(termsQuery(FIELD_ACTIVE_RULE_PROFILE_KEY, profileKey)));
+ .setQuery(QueryBuilders.boolQuery().must(termQuery(FIELD_ACTIVE_RULE_PROFILE_UUID, profile.getRulesProfileUuid())));
bulk.addDeletion(search);
});
bulk.stop();
}
- private void deleteKeys(List<ActiveRuleKey> keys) {
- BulkIndexer bulk = createBulkIndexer();
+ public void deleteByRuleKeys(Collection<RuleKey> ruleKeys) {
+ BulkIndexer bulk = createBulkIndexer(Size.REGULAR);
bulk.start();
- SearchRequestBuilder search = esClient.prepareSearch(INDEX_TYPE_ACTIVE_RULE)
- .setQuery(QueryBuilders.boolQuery().must(termsQuery(FIELD_ACTIVE_RULE_KEY, keys)));
- bulk.addDeletion(search);
+ ruleKeys.forEach(ruleKey -> {
+ SearchRequestBuilder search = esClient.prepareSearch(INDEX_TYPE_ACTIVE_RULE)
+ .setQuery(QueryBuilders.boolQuery().must(termQuery(FIELD_ACTIVE_RULE_RULE_KEY, ruleKey.toString())));
+ bulk.addDeletion(search);
+ });
bulk.stop();
}
- private BulkIndexer createBulkIndexer() {
- return new BulkIndexer(esClient, INDEX_TYPE_ACTIVE_RULE.getIndex(), Size.REGULAR);
+ private BulkIndexer createBulkIndexer(Size size) {
+ return new BulkIndexer(esClient, INDEX_TYPE_ACTIVE_RULE.getIndex(), size);
}
private static IndexRequest newIndexRequest(ActiveRuleDoc doc) {
- return new IndexRequest(INDEX_TYPE_ACTIVE_RULE.getIndex(), INDEX_TYPE_ACTIVE_RULE.getType(), doc.key().toString())
- .parent(doc.key().ruleKey().toString())
+ return new IndexRequest(INDEX_TYPE_ACTIVE_RULE.getIndex(), INDEX_TYPE_ACTIVE_RULE.getType(), doc.getId())
+ .parent(doc.getRuleKey().toString())
.source(doc.getFields());
}
+
+ private void scrollDbAndIndex(ActiveRuleIterator dbCursor, Size size) {
+ BulkIndexer bulk = new BulkIndexer(esClient, INDEX_TYPE_ACTIVE_RULE.getIndex(), size);
+ bulk.start();
+ while (dbCursor.hasNext()) {
+ ActiveRuleDoc activeRule = dbCursor.next();
+ bulk.add(newIndexRequest(activeRule));
+ }
+ bulk.stop();
+ }
}
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2017 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+package org.sonar.server.qualityprofile.index;
+
+import java.util.Iterator;
+
+public interface ActiveRuleIterator extends Iterator<ActiveRuleDoc>, AutoCloseable {
+ @Override
+ void close();
+}
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2017 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+package org.sonar.server.qualityprofile.index;
+
+import java.util.Collection;
+import org.sonar.api.server.ServerSide;
+import org.sonar.db.DbClient;
+import org.sonar.db.DbSession;
+import org.sonar.db.qualityprofile.RulesProfileDto;
+
+@ServerSide
+public class ActiveRuleIteratorFactory {
+
+ private final DbClient dbClient;
+
+ public ActiveRuleIteratorFactory(DbClient dbClient) {
+ this.dbClient = dbClient;
+ }
+
+ public ActiveRuleIterator createForAll(DbSession dbSession) {
+ return new ActiveRuleIteratorForSingleChunk(dbClient, dbSession);
+ }
+
+ public ActiveRuleIterator createForRuleProfile(DbSession dbSession, RulesProfileDto ruleProfile) {
+ return new ActiveRuleIteratorForSingleChunk(dbClient, dbSession, ruleProfile);
+ }
+
+ public ActiveRuleIterator createForActiveRules(DbSession dbSession, Collection<Integer> activeRuleIds) {
+ return new ActiveRuleIteratorForMultipleChunks(dbClient, dbSession, activeRuleIds);
+ }
+}
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2017 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+package org.sonar.server.qualityprofile.index;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import org.sonar.db.DatabaseUtils;
+import org.sonar.db.DbClient;
+import org.sonar.db.DbSession;
+
+import static java.util.Optional.ofNullable;
+
+public class ActiveRuleIteratorForMultipleChunks implements ActiveRuleIterator {
+
+ private final DbClient dbClient;
+ private final DbSession dbSession;
+ private final Iterator<List<Integer>> iteratorOverChunks;
+ private ActiveRuleIteratorForSingleChunk currentChunk;
+
+ public ActiveRuleIteratorForMultipleChunks(DbClient dbClient, DbSession dbSession, Collection<Integer> activeRuleIds) {
+ this.dbClient = dbClient;
+ this.dbSession = dbSession;
+ this.iteratorOverChunks = DatabaseUtils.toUniqueAndSortedPartitions(activeRuleIds).iterator();
+ }
+
+ @Override
+ public boolean hasNext() {
+ if (currentChunk != null && currentChunk.hasNext()) {
+ return true;
+ }
+ return iteratorOverChunks.hasNext();
+ }
+
+ @Override
+ public ActiveRuleDoc next() {
+ if (currentChunk == null || !currentChunk.hasNext()) {
+ currentChunk = nextChunk();
+ }
+ return currentChunk.next();
+ }
+
+ private ActiveRuleIteratorForSingleChunk nextChunk() {
+ List<Integer> nextInput = iteratorOverChunks.next();
+ return new ActiveRuleIteratorForSingleChunk(dbClient, dbSession, nextInput);
+ }
+
+ @Override
+ public void close() {
+ ofNullable(currentChunk).ifPresent(ActiveRuleIterator::close);
+ }
+}
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2017 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+package org.sonar.server.qualityprofile.index;
+
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.List;
+import org.apache.commons.lang.StringUtils;
+import org.sonar.api.rule.RuleKey;
+import org.sonar.db.DatabaseUtils;
+import org.sonar.db.DbClient;
+import org.sonar.db.DbSession;
+import org.sonar.db.ResultSetIterator;
+import org.sonar.db.qualityprofile.RulesProfileDto;
+import org.sonar.db.rule.SeverityUtil;
+import org.sonar.server.qualityprofile.ActiveRule;
+
+import static org.apache.commons.lang.StringUtils.repeat;
+
+/**
+ * Scrolls over table ISSUES and reads documents to populate
+ * the issues index
+ */
+class ActiveRuleIteratorForSingleChunk implements ActiveRuleIterator {
+
+ private static final String[] COLUMNS = {
+ "ar.id",
+ "ar.failure_level",
+ "ar.inheritance",
+ "r.plugin_name",
+ "r.plugin_rule_key",
+ "rp.kee"
+ };
+
+ private static final String SQL_ALL = "select " + StringUtils.join(COLUMNS, ",") + " from active_rules ar " +
+ " inner join rules_profiles rp on rp.id = ar.profile_id " +
+ " inner join rules r on r.id = ar.rule_id ";
+
+ private final PreparedStatement stmt;
+ private final ResultSetIterator<ActiveRuleDoc> iterator;
+
+ ActiveRuleIteratorForSingleChunk(DbClient dbClient, DbSession dbSession) {
+ try {
+ stmt = dbClient.getMyBatis().newScrollingSelectStatement(dbSession, SQL_ALL);
+ iterator = new ActiveRuleIteratorInternal(stmt);
+ } catch (Exception e) {
+ throw new IllegalStateException("Fail to prepare SQL request to select all active_rules", e);
+ }
+ }
+
+ ActiveRuleIteratorForSingleChunk(DbClient dbClient, DbSession dbSession, RulesProfileDto ruleProfile) {
+ try {
+ stmt = dbClient.getMyBatis().newScrollingSelectStatement(dbSession, SQL_ALL + " where rp.kee = ?");
+ stmt.setString(1, ruleProfile.getKee());
+ iterator = new ActiveRuleIteratorInternal(stmt);
+ } catch (Exception e) {
+ throw new IllegalStateException("Fail to prepare SQL request to select active_rules of profile " + ruleProfile.getKee(), e);
+ }
+ }
+
+ ActiveRuleIteratorForSingleChunk(DbClient dbClient, DbSession dbSession, List<Integer> activeRuleIds) {
+ try {
+ stmt = dbClient.getMyBatis().newScrollingSelectStatement(dbSession, SQL_ALL + " where ar.id in (" + repeat("?", ",", activeRuleIds.size()) + ")");
+ for (int i = 0; i < activeRuleIds.size(); i++) {
+ stmt.setInt(i + 1, activeRuleIds.get(i));
+ }
+ iterator = new ActiveRuleIteratorInternal(stmt);
+ } catch (Exception e) {
+ throw new IllegalStateException("Fail to prepare SQL request to select active_rules", e);
+ }
+ }
+
+ @Override
+ public boolean hasNext() {
+ return iterator.hasNext();
+ }
+
+ @Override
+ public ActiveRuleDoc next() {
+ return iterator.next();
+ }
+
+ @Override
+ public void close() {
+ try {
+ iterator.close();
+ } finally {
+ DatabaseUtils.closeQuietly(stmt);
+ }
+ }
+
+ private static final class ActiveRuleIteratorInternal extends ResultSetIterator<ActiveRuleDoc> {
+
+ ActiveRuleIteratorInternal(PreparedStatement stmt) throws SQLException {
+ super(stmt);
+ }
+
+ @Override
+ protected ActiveRuleDoc read(ResultSet rs) throws SQLException {
+ long activeRuleId = rs.getLong(1);
+ int severity = rs.getInt(2);
+ String inheritance = rs.getString(3);
+ RuleKey ruleKey = RuleKey.of(rs.getString(4), rs.getString(5));
+ String ruleProfileUuid = rs.getString(6);
+
+ return new ActiveRuleDoc(String.valueOf(activeRuleId))
+ .setRuleProfileUuid(ruleProfileUuid)
+ .setRuleKey(ruleKey)
+ // all the fields must be present, even if value is null
+ .setSeverity(SeverityUtil.getSeverityFromOrdinal(severity))
+ .setInheritance(inheritance == null ? ActiveRule.Inheritance.NONE.name() : inheritance);
+ }
+ }
+}
+++ /dev/null
-/*
- * SonarQube
- * Copyright (C) 2009-2017 SonarSource SA
- * mailto:info AT sonarsource DOT com
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 3 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-package org.sonar.server.qualityprofile.index;
-
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import org.apache.commons.lang.StringUtils;
-import org.sonar.api.rule.RuleKey;
-import org.sonar.db.DbClient;
-import org.sonar.db.DbSession;
-import org.sonar.db.ResultSetIterator;
-import org.sonar.db.qualityprofile.ActiveRuleKey;
-import org.sonar.db.rule.SeverityUtil;
-import org.sonar.server.qualityprofile.ActiveRule;
-
-/**
- * Scrolls over table ACTIVE_RULES and reads documents to populate the active rules index
- */
-public class ActiveRuleResultSetIterator extends ResultSetIterator<ActiveRuleDoc> {
-
- private static final String[] FIELDS = {
- "ar.failure_level",
- "ar.inheritance",
- "r.plugin_name",
- "r.plugin_rule_key",
- "oqp.organization_uuid",
- "oqp.uuid",
- "ar.updated_at"
- };
-
- private static final String SQL_ALL = "select " + StringUtils.join(FIELDS, ",") + " from active_rules ar " +
- " inner join rules_profiles rp on rp.id = ar.profile_id " +
- " inner join org_qprofiles oqp on oqp.uuid = rp.kee " +
- " inner join rules r on r.id = ar.rule_id ";
-
- private static final String SQL_AFTER_DATE = SQL_ALL + " where ar.updated_at>?";
-
- private ActiveRuleResultSetIterator(PreparedStatement stmt) throws SQLException {
- super(stmt);
- }
-
- static ActiveRuleResultSetIterator create(DbClient dbClient, DbSession session, long afterDate) {
- try {
- String sql = afterDate > 0L ? SQL_AFTER_DATE : SQL_ALL;
- PreparedStatement stmt = dbClient.getMyBatis().newScrollingSelectStatement(session, sql);
- if (afterDate > 0L) {
- stmt.setLong(1, afterDate);
- }
- return new ActiveRuleResultSetIterator(stmt);
- } catch (SQLException e) {
- throw new IllegalStateException("Fail to prepare SQL request to select all active rules", e);
- }
- }
-
- @Override
- protected ActiveRuleDoc read(ResultSet rs) throws SQLException {
- int severity = rs.getInt(1);
- String inheritance = rs.getString(2);
- RuleKey ruleKey = RuleKey.of(rs.getString(3), rs.getString(4));
- String organizationUuid = rs.getString(5);
- String profileKey = rs.getString(6);
- ActiveRuleKey activeRuleKey = ActiveRuleKey.of(profileKey, ruleKey);
-
- ActiveRuleDoc doc = new ActiveRuleDoc(activeRuleKey);
- doc.setOrganizationUuid(organizationUuid);
- // all the fields must be present, even if value is null
- doc.setSeverity(SeverityUtil.getSeverityFromOrdinal(severity));
-
- doc.setInheritance(inheritance == null ? ActiveRule.Inheritance.NONE.name() : inheritance);
-
- doc.setUpdatedAt(rs.getLong(7));
- return doc;
- }
-
-}
QProfileDto profile = wsSupport.getProfile(dbSession, QProfileReference.fromKey(profileKey));
wsSupport.checkPermission(dbSession, profile);
wsSupport.checkNotBuiltInt(profile);
- List<ActiveRuleChange> changes = ruleActivator.activate(dbSession, activation, profileKey);
+ List<ActiveRuleChange> changes = ruleActivator.activate(dbSession, activation, profile);
dbSession.commit();
- activeRuleIndexer.index(changes);
+ activeRuleIndexer.indexChanges(dbSession, changes);
}
response.noContent();
}
QProfileDto profile = wsSupport.getProfile(dbSession, fromKey(qualityProfileKey));
wsSupport.checkPermission(dbSession, profile);
wsSupport.checkNotBuiltInt(profile);
- result = ruleActivator.bulkActivate(ruleQueryFactory.createRuleQuery(dbSession, request), qualityProfileKey, request.param(SEVERITY));
+ result = ruleActivator.bulkActivate(dbSession, ruleQueryFactory.createRuleQuery(dbSession, request), profile, request.param(SEVERITY));
}
BulkChangeWsResponse.writeResponse(result, response);
}
String parentKey = request.param(PARAM_PARENT_KEY);
String parentName = request.param(PARAM_PARENT_NAME);
if (isEmpty(parentKey) && isEmpty(parentName)) {
- ruleActivator.setParent(dbSession, profile.getKee(), null);
+ ruleActivator.setParent(dbSession, profile, null);
} else {
String parentOrganizationKey = parentKey == null ? organization.getKey() : null;
String parentLanguage = parentKey == null ? request.param(PARAM_LANGUAGE) : null;
QProfileReference parentRef = QProfileReference.from(parentKey, parentOrganizationKey, parentLanguage, parentName);
QProfileDto parent = wsSupport.getProfile(dbSession, parentRef);
- ruleActivator.setParent(dbSession, profile.getKee(), parent.getKee());
+ ruleActivator.setParent(dbSession, profile, parent);
}
response.noContent();
}
json.endObject().close();
}
- private void writeParameters(JsonWriter json, ChangelogLoader.Change change) {
+ private static void writeParameters(JsonWriter json, ChangelogLoader.Change change) {
json.name("params").beginObject()
.prop("severity", change.getSeverity());
for (Map.Entry<String, String> param : change.getParams().entrySet()) {
.collect(MoreCollectors.toList(dtos.size()));
completeUserAndRuleNames(dbSession, changes);
- int total = dbClient.qProfileChangeDao().countForProfileUuid(dbSession, query.getProfileUuid());
+ int total = dbClient.qProfileChangeDao().countForQProfileUuid(dbSession, query.getProfileUuid());
return new Changelog(total, changes);
}
private static Change from(QProfileChangeDto dto) {
Map<String, String> data = dto.getDataAsMap();
Change change = new Change();
- change.key = dto.getKey();
+ change.key = dto.getUuid();
change.userLogin = dto.getLogin();
change.type = dto.getChangeType();
change.at = dto.getCreatedAt();
}
}
dbSession.commit();
- activeRuleIndexer.index(result.getChanges());
+ activeRuleIndexer.indexChanges(dbSession, result.getChanges());
return buildResponse(result, organization);
}
import org.sonar.core.util.Uuids;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
-import org.sonar.db.qualityprofile.ActiveRuleKey;
import org.sonar.db.qualityprofile.QProfileDto;
import org.sonar.server.qualityprofile.RuleActivator;
import org.sonar.server.user.UserSession;
QProfileDto profile = wsSupport.getProfile(dbSession, QProfileReference.fromKey(qualityProfileKey));
wsSupport.checkPermission(dbSession, profile);
wsSupport.checkNotBuiltInt(profile);
- ActiveRuleKey activeRuleKey = ActiveRuleKey.of(qualityProfileKey, ruleKey);
- ruleActivator.deactivateAndUpdateIndex(dbSession, activeRuleKey);
+ ruleActivator.deactivateAndUpdateIndex(dbSession, profile, ruleKey);
}
response.noContent();
}
QProfileDto profile = wsSupport.getProfile(dbSession, QProfileReference.fromKey(qualityProfileKey));
wsSupport.checkPermission(dbSession, profile);
wsSupport.checkNotBuiltInt(profile);
- result = ruleActivator.bulkDeactivate(ruleQueryFactory.createRuleQuery(dbSession, request), qualityProfileKey);
+ result = ruleActivator.bulkDeactivate(dbSession, ruleQueryFactory.createRuleQuery(dbSession, request), profile);
}
BulkChangeWsResponse.writeResponse(result, response);
}
List<QProfileDto> descendants = selectDescendants(dbSession, profile);
ensureNoneIsMarkedAsDefault(dbSession, profile, descendants);
- profileFactory.deleteByKeys(dbSession, toKeys(profile, descendants));
+ profileFactory.delete(dbSession, merge(profile, descendants));
dbSession.commit();
}
response.noContent();
}
private List<QProfileDto> selectDescendants(DbSession dbSession, QProfileDto profile) {
- return dbClient.qualityProfileDao().selectDescendants(dbSession, profile.getKee());
+ return dbClient.qualityProfileDao().selectDescendants(dbSession, profile);
}
private void ensureNoneIsMarkedAsDefault(DbSession dbSession, QProfileDto profile, List<QProfileDto> descendants) {
});
}
- private static List<String> toKeys(QProfileDto profile, List<QProfileDto> descendants) {
+ private static List<QProfileDto> merge(QProfileDto profile, List<QProfileDto> descendants) {
return Stream.concat(Stream.of(profile), descendants.stream())
- .map(QProfileDto::getKee)
.collect(MoreCollectors.toList(descendants.size() + 1));
}
}
backuper.backup(dbSession, profile, writer);
} else {
stream.setMediaType(exporters.mimeType(exporterKey));
- exporters.export(profile, exporterKey, writer);
+ exporters.export(dbSession, profile, exporterKey, writer);
}
}
}
OrganizationDto organization = dbClient.organizationDao().selectByUuid(dbSession, organizationUuid)
.orElseThrow(() -> new IllegalStateException(String.format("Could not find organization with uuid '%s' for quality profile '%s'", organizationUuid, profile.getKee())));
List<QProfileDto> ancestors = profileLookup.ancestors(profile, dbSession);
- List<QProfileDto> children = dbClient.qualityProfileDao().selectChildren(dbSession, profile.getKee());
+ List<QProfileDto> children = dbClient.qualityProfileDao().selectChildren(dbSession, profile);
Statistics statistics = new Statistics(dbSession, organization);
writeProtobuf(buildResponse(profile, ancestors, children, statistics), request, response);
private Statistics(DbSession dbSession, OrganizationDto organization) {
ActiveRuleDao dao = dbClient.activeRuleDao();
- countRulesByProfileKey = dao.countActiveRulesByProfileKey(dbSession, organization);
- countOverridingRulesByProfileKey = dao.countActiveRulesForInheritanceByProfileKey(dbSession, organization, ActiveRuleDto.OVERRIDES);
+ countRulesByProfileKey = dao.countActiveRulesByProfileUuid(dbSession, organization);
+ countOverridingRulesByProfileKey = dao.countActiveRulesForInheritanceByProfileUuid(dbSession, organization, ActiveRuleDto.OVERRIDES);
}
}
}
return new SearchData()
.setOrganization(organization)
.setProfiles(profiles)
- .setActiveRuleCountByProfileKey(dbClient.activeRuleDao().countActiveRulesByProfileKey(dbSession, organization))
- .setActiveDeprecatedRuleCountByProfileKey(dbClient.activeRuleDao().countActiveRulesForRuleStatusByProfileKey(dbSession, organization, RuleStatus.DEPRECATED))
+ .setActiveRuleCountByProfileKey(dbClient.activeRuleDao().countActiveRulesByProfileUuid(dbSession, organization))
+ .setActiveDeprecatedRuleCountByProfileKey(dbClient.activeRuleDao().countActiveRulesForRuleStatusByProfileUuid(dbSession, organization, RuleStatus.DEPRECATED))
.setProjectCountByProfileKey(dbClient.qualityProfileDao().countProjectsByProfileUuid(dbSession, organization))
.setDefaultProfileKeys(defaultProfiles);
}
@Override
public void start() {
Profiler profiler = Profiler.create(LOG).startInfo("Register rules");
- try (DbSession session = dbClient.openSession(false)) {
- Map<RuleKey, RuleDefinitionDto> allRules = loadRules(session);
+ try (DbSession dbSession = dbClient.openSession(false)) {
+ Map<RuleKey, RuleDefinitionDto> allRules = loadRules(dbSession);
List<RuleKey> keysToIndex = new ArrayList<>();
RulesDefinition.Context context = defLoader.load();
- boolean orgsEnabled = organizationFlags.isEnabled(session);
+ boolean orgsEnabled = organizationFlags.isEnabled(dbSession);
for (RulesDefinition.ExtendedRepository repoDef : getRepositories(context)) {
if (languages.get(repoDef.language()) != null) {
for (RulesDefinition.Rule ruleDef : repoDef.rules()) {
}
continue;
}
- boolean relevantForIndex = registerRule(ruleDef, allRules, session);
+ boolean relevantForIndex = registerRule(ruleDef, allRules, dbSession);
if (relevantForIndex) {
keysToIndex.add(ruleKey);
}
}
- session.commit();
+ dbSession.commit();
}
}
- List<RuleDefinitionDto> removedRules = processRemainingDbRules(allRules.values(), session);
- List<ActiveRuleChange> changes = removeActiveRulesOnStillExistingRepositories(session, removedRules, context);
- session.commit();
+ List<RuleDefinitionDto> removedRules = processRemainingDbRules(allRules.values(), dbSession);
+ List<ActiveRuleChange> changes = removeActiveRulesOnStillExistingRepositories(dbSession, removedRules, context);
+ dbSession.commit();
keysToIndex.addAll(removedRules.stream().map(RuleDefinitionDto::getKey).collect(Collectors.toList()));
- persistRepositories(session, context.repositories());
+ persistRepositories(dbSession, context.repositories());
ruleIndexer.indexRuleDefinitions(keysToIndex);
- activeRuleIndexer.index(changes);
+ activeRuleIndexer.indexChanges(dbSession, changes);
profiler.stopDebug();
webServerRuleFinder.startCaching();
RulesDefinition.Param paramDef = ruleDef.param(paramDto.getName());
if (paramDef == null) {
profiler.start();
- dbClient.activeRuleDao().deleteParamsByRuleParamOfAllOrganizations(session, rule.getId(), paramDto.getName());
+ dbClient.activeRuleDao().deleteParamsByRuleParamOfAllOrganizations(session, paramDto);
profiler.stopDebug(format("Propagate deleted param with name %s to active rules of rule %s", paramDto.getName(), rule.getKey()));
dbClient.ruleDao().deleteRuleParam(session, paramDto.getId());
} else {
import org.sonar.db.organization.OrganizationDto;
import org.sonar.db.qualityprofile.ActiveRuleDto;
import org.sonar.db.qualityprofile.ActiveRuleParamDto;
+import org.sonar.db.qualityprofile.OrgActiveRuleDto;
import org.sonar.db.rule.RuleDefinitionDto;
import org.sonar.db.rule.RuleDto;
import org.sonar.db.rule.RuleParamDto;
}
private Multimap<ActiveRuleDto, ActiveRuleParamDto> getActiveRuleParamsByActiveRule(DbSession dbSession, OrganizationDto organization, RuleDto customRule) {
- List<ActiveRuleDto> activeRuleDtos = dbClient.activeRuleDao().selectByRuleId(dbSession, organization, customRule.getId());
- Map<Integer, ActiveRuleDto> activeRuleById = from(activeRuleDtos).uniqueIndex(ActiveRuleDto::getId);
+ List<OrgActiveRuleDto> activeRuleDtos = dbClient.activeRuleDao().selectByRuleId(dbSession, organization, customRule.getId());
+ Map<Integer, OrgActiveRuleDto> activeRuleById = from(activeRuleDtos).uniqueIndex(ActiveRuleDto::getId);
List<Integer> activeRuleIds = Lists.transform(activeRuleDtos, ActiveRuleDto::getId);
List<ActiveRuleParamDto> activeRuleParamDtos = dbClient.activeRuleDao().selectParamsByActiveRuleIds(dbSession, activeRuleIds);
return from(activeRuleParamDtos)
}
private static class ActiveRuleParamToActiveRule implements Function<ActiveRuleParamDto, ActiveRuleDto> {
- private final Map<Integer, ActiveRuleDto> activeRuleById;
+ private final Map<Integer, OrgActiveRuleDto> activeRuleById;
- private ActiveRuleParamToActiveRule(Map<Integer, ActiveRuleDto> activeRuleById) {
+ private ActiveRuleParamToActiveRule(Map<Integer, OrgActiveRuleDto> activeRuleById) {
this.activeRuleById = activeRuleById;
}
@Override
- public ActiveRuleDto apply(@Nonnull ActiveRuleParamDto input) {
+ public OrgActiveRuleDto apply(@Nonnull ActiveRuleParamDto input) {
return activeRuleById.get(input.getActiveRuleId());
}
}
.uniqueIndex(ActiveRuleParamDto::getKey);
ActiveRuleParamDto activeRuleParamDto = activeRuleParamByKey.get(ruleParamDto.getName());
if (activeRuleParamDto != null) {
- dbClient.activeRuleDao().updateParam(dbSession, activeRuleDto, activeRuleParamDto.setValue(ruleParamDto.getDefaultValue()));
+ dbClient.activeRuleDao().updateParam(dbSession, activeRuleParamDto.setValue(ruleParamDto.getDefaultValue()));
} else {
dbClient.activeRuleDao().insertParam(dbSession, activeRuleDto, ActiveRuleParamDto.createFor(ruleParamDto).setValue(ruleParamDto.getDefaultValue()));
}
import static org.sonar.server.es.EsUtils.escapeSpecialRegexChars;
import static org.sonar.server.es.EsUtils.scrollIds;
import static org.sonar.server.rule.index.RuleIndexDefinition.FIELD_ACTIVE_RULE_INHERITANCE;
-import static org.sonar.server.rule.index.RuleIndexDefinition.FIELD_ACTIVE_RULE_ORGANIZATION_UUID;
-import static org.sonar.server.rule.index.RuleIndexDefinition.FIELD_ACTIVE_RULE_PROFILE_KEY;
+import static org.sonar.server.rule.index.RuleIndexDefinition.FIELD_ACTIVE_RULE_PROFILE_UUID;
import static org.sonar.server.rule.index.RuleIndexDefinition.FIELD_ACTIVE_RULE_SEVERITY;
import static org.sonar.server.rule.index.RuleIndexDefinition.FIELD_RULE_CREATED_AT;
import static org.sonar.server.rule.index.RuleIndexDefinition.FIELD_RULE_EXTENSION_SCOPE;
if (isNotEmpty(query.getTags())) {
BoolQueryBuilder q = boolQuery();
- String organizationUuid = query.getOrganizationUuid();
query.getTags().stream()
.map(tag -> boolQuery()
.filter(QueryBuilders.termQuery(FIELD_RULE_EXTENSION_TAGS, tag))
- .filter(termsQuery(FIELD_RULE_EXTENSION_SCOPE, RuleExtensionScope.system().getScope(), RuleExtensionScope.organization(organizationUuid).getScope())))
+ .filter(termsQuery(FIELD_RULE_EXTENSION_SCOPE, RuleExtensionScope.system().getScope(), RuleExtensionScope.organization(query.getOrganization()).getScope())))
.map(childQuery -> QueryBuilders.hasChildQuery(INDEX_TYPE_RULE_EXTENSION.getType(), childQuery))
.forEach(q::filter);
filters.put(FIELD_RULE_EXTENSION_TAGS, q);
}
/* Implementation of activation query */
- if (query.getActivation() != null) {
+ if (query.getActivation() != null && query.getQProfile() != null) {
// ActiveRule Filter (profile and inheritance)
BoolQueryBuilder childrenFilter = boolQuery();
- addTermFilter(childrenFilter, FIELD_ACTIVE_RULE_PROFILE_KEY, query.getQProfileKey());
+ addTermFilter(childrenFilter, FIELD_ACTIVE_RULE_PROFILE_UUID, query.getQProfile().getRulesProfileUuid());
addTermFilter(childrenFilter, FIELD_ACTIVE_RULE_INHERITANCE, query.getInheritance());
addTermFilter(childrenFilter, FIELD_ACTIVE_RULE_SEVERITY, query.getActiveSeverities());
- addTermFilter(childrenFilter, FIELD_ACTIVE_RULE_ORGANIZATION_UUID, query.getOrganizationUuid());
// ChildQuery
QueryBuilder childQuery;
}
if (options.getFacets().contains(FACET_TAGS) || options.getFacets().contains(FACET_OLD_DEFAULT)) {
Collection<String> tags = query.getTags();
- String organizationUuid = query.getOrganizationUuid();
- checkArgument(organizationUuid != null, "Cannot use tags facet, if no organization is specified.", query.getTags());
+ checkArgument(query.getOrganization() != null, "Cannot use tags facet, if no organization is specified.", query.getTags());
Function<TermsBuilder, AggregationBuilder<?>> childFeature = termsAggregation -> {
FilterAggregationBuilder scopeAggregation = AggregationBuilders.filter("scope_filter_for_" + FACET_TAGS).filter(
termsQuery(FIELD_RULE_EXTENSION_SCOPE,
RuleExtensionScope.system().getScope(),
- RuleExtensionScope.organization(organizationUuid).getScope()))
+ RuleExtensionScope.organization(query.getOrganization()).getScope()))
.subAggregation(termsAggregation);
return AggregationBuilders.children("children_for_" + termsAggregation.getName())
// Rebuilding the active rule filter without severities
BoolQueryBuilder childrenFilter = boolQuery();
- addTermFilter(childrenFilter, FIELD_ACTIVE_RULE_PROFILE_KEY, query.getQProfileKey());
+ addTermFilter(childrenFilter, FIELD_ACTIVE_RULE_PROFILE_UUID, query.getQProfile().getRulesProfileUuid());
RuleIndex.addTermFilter(childrenFilter, FIELD_ACTIVE_RULE_INHERITANCE, query.getInheritance());
QueryBuilder activeRuleFilter;
if (childrenFilter.hasClauses()) {
// Active rule fields
public static final IndexType INDEX_TYPE_ACTIVE_RULE = new IndexType(INDEX, "activeRule");
- public static final String FIELD_ACTIVE_RULE_ORGANIZATION_UUID = "organizationUuid";
- public static final String FIELD_ACTIVE_RULE_KEY = "key";
public static final String FIELD_ACTIVE_RULE_REPOSITORY = "repo";
public static final String FIELD_ACTIVE_RULE_INHERITANCE = "inheritance";
- public static final String FIELD_ACTIVE_RULE_PROFILE_KEY = "profile";
+ public static final String FIELD_ACTIVE_RULE_PROFILE_UUID = "ruleProfile";
public static final String FIELD_ACTIVE_RULE_SEVERITY = "severity";
public static final String FIELD_ACTIVE_RULE_RULE_KEY = "ruleKey";
- public static final String FIELD_ACTIVE_RULE_UPDATED_AT = "updatedAt";
private final Settings settings;
+ private final boolean enableSource;
public RuleIndexDefinition(Settings settings) {
+ this(settings, false);
+ }
+
+ private RuleIndexDefinition(Settings settings, boolean enableSource) {
this.settings = settings;
+ this.enableSource = enableSource;
+ }
+
+ /**
+ * Keep the document sources in index so that indexer tests can verify content
+ * of indexed documents.
+ */
+ public static RuleIndexDefinition createForTest(Settings settings) {
+ return new RuleIndexDefinition(settings, true);
}
@Override
// Active rule type
NewIndex.NewIndexType activeRuleMapping = index.createType(INDEX_TYPE_ACTIVE_RULE.getType());
- activeRuleMapping.setEnableSource(false);
+ activeRuleMapping.setEnableSource(enableSource);
activeRuleMapping.setAttribute("_parent", ImmutableMap.of("type", INDEX_TYPE_RULE.getType()));
- activeRuleMapping.stringFieldBuilder(FIELD_ACTIVE_RULE_ORGANIZATION_UUID).disableNorms().build();
- activeRuleMapping.stringFieldBuilder(FIELD_ACTIVE_RULE_KEY).addSubFields(SORTABLE_ANALYZER).build();
activeRuleMapping.stringFieldBuilder(FIELD_ACTIVE_RULE_RULE_KEY).addSubFields(SORTABLE_ANALYZER).build();
activeRuleMapping.stringFieldBuilder(FIELD_ACTIVE_RULE_REPOSITORY).build();
- activeRuleMapping.stringFieldBuilder(FIELD_ACTIVE_RULE_PROFILE_KEY).disableNorms().build();
+ activeRuleMapping.stringFieldBuilder(FIELD_ACTIVE_RULE_PROFILE_UUID).disableNorms().build();
activeRuleMapping.stringFieldBuilder(FIELD_ACTIVE_RULE_INHERITANCE).disableNorms().build();
activeRuleMapping.stringFieldBuilder(FIELD_ACTIVE_RULE_SEVERITY).disableNorms().build();
- activeRuleMapping.createLongField(FIELD_ACTIVE_RULE_UPDATED_AT);
// Rule extension type
NewIndex.NewIndexType ruleExtensionType = index.createType(INDEX_TYPE_RULE_EXTENSION.getType());
- ruleExtensionType.setEnableSource(false);
+ ruleExtensionType.setEnableSource(enableSource);
ruleExtensionType.setAttribute("_parent", ImmutableMap.of("type", INDEX_TYPE_RULE.getType()));
ruleExtensionType.stringFieldBuilder(FIELD_RULE_EXTENSION_SCOPE).disableNorms().build();
// Rule type
NewIndex.NewIndexType ruleMapping = index.createType(INDEX_TYPE_RULE.getType());
- ruleMapping.setEnableSource(false);
+ ruleMapping.setEnableSource(enableSource);
ruleMapping.stringFieldBuilder(FIELD_RULE_KEY).addSubFields(SORTABLE_ANALYZER).build();
ruleMapping.stringFieldBuilder(FIELD_RULE_RULE_KEY).addSubFields(SORTABLE_ANALYZER).build();
ruleMapping.createBooleanField(FIELD_RULE_IS_TEMPLATE);
ruleMapping.stringFieldBuilder(FIELD_RULE_TEMPLATE_KEY).disableNorms().build();
-
+
ruleMapping.stringFieldBuilder(FIELD_RULE_TYPE).disableNorms().build();
ruleMapping.createLongField(FIELD_RULE_CREATED_AT);
private static final String[] FIELDS = {
// column 1
- "r.plugin_rule_key",
"r.plugin_name",
+ "r.plugin_rule_key",
"r.name",
"r.description",
"r.description_format",
RuleDoc doc = new RuleDoc();
RuleExtensionDoc extensionDoc = new RuleExtensionDoc().setScope(RuleExtensionScope.system());
- String ruleKey = rs.getString(1);
- String repositoryKey = rs.getString(2);
+ String repositoryKey = rs.getString(1);
+ String ruleKey = rs.getString(2);
RuleKey key = RuleKey.of(repositoryKey, ruleKey);
extensionDoc.setRuleKey(key);
protected RuleExtensionDoc read(ResultSet rs) throws SQLException {
RuleExtensionDoc doc = new RuleExtensionDoc();
- String ruleKey = rs.getString(1);
- String repositoryKey = rs.getString(2);
+ String repositoryKey = rs.getString(1);
+ String ruleKey = rs.getString(2);
RuleKey key = RuleKey.of(repositoryKey, ruleKey);
doc.setRuleKey(key);
doc.setScope(RuleExtensionScope.organization(rs.getString(3)));
import org.sonar.api.rule.RuleStatus;
import org.sonar.api.rule.Severity;
import org.sonar.api.rules.RuleType;
+import org.sonar.db.organization.OrganizationDto;
+import org.sonar.db.qualityprofile.QProfileDto;
import static java.util.Arrays.asList;
private Collection<String> tags;
private Collection<RuleType> types;
private Boolean activation;
- private String qProfileKey;
+ private QProfileDto profile;
private Collection<String> inheritance;
private Collection<String> activeSeverities;
private String templateKey;
private boolean ascendingSort = true;
private String internalKey;
private String ruleKey;
- private String organizationUuid;
+ private OrganizationDto organization;
@CheckForNull
- public String getQProfileKey() {
- return qProfileKey;
+ public QProfileDto getQProfile() {
+ return profile;
}
- public RuleQuery setQProfileKey(@Nullable String s) {
- this.qProfileKey = s;
+ public RuleQuery setQProfile(@Nullable QProfileDto p) {
+ this.profile = p;
return this;
}
return this;
}
+ @CheckForNull
public String getInternalKey() {
return internalKey;
}
return this;
}
+ @CheckForNull
public String getRuleKey() {
return ruleKey;
}
- public String getOrganizationUuid() {
- return organizationUuid;
+ public OrganizationDto getOrganization() {
+ return organization;
}
- public RuleQuery setOrganizationUuid(String organizationUuid) {
- this.organizationUuid = organizationUuid;
+ public RuleQuery setOrganization(OrganizationDto o) {
+ this.organization = o;
return this;
}
}
import com.google.common.collect.ListMultimap;
import com.google.common.collect.Lists;
import com.google.common.collect.Multimap;
+import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
+import java.util.Set;
import java.util.stream.Collectors;
-import javax.annotation.CheckForNull;
+import org.apache.commons.lang.StringUtils;
import org.sonar.api.resources.Language;
import org.sonar.api.resources.Languages;
import org.sonar.api.rule.RuleKey;
import org.sonar.api.server.ServerSide;
import org.sonar.api.utils.DateUtils;
-import org.sonar.api.utils.log.Logger;
-import org.sonar.api.utils.log.Loggers;
import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import org.sonar.db.qualityprofile.ActiveRuleDto;
import org.sonar.db.qualityprofile.ActiveRuleKey;
import org.sonar.db.qualityprofile.ActiveRuleParamDto;
+import org.sonar.db.qualityprofile.OrgActiveRuleDto;
import org.sonar.db.qualityprofile.QProfileDto;
import org.sonar.db.rule.RuleDefinitionDto;
import org.sonar.db.rule.RuleDto;
import org.sonarqube.ws.Rules.SearchResponse;
import static com.google.common.base.Strings.nullToEmpty;
-import static com.google.common.collect.FluentIterable.from;
-import static com.google.common.collect.Sets.newHashSet;
import static java.util.Collections.singletonList;
import static org.sonar.core.util.Protobuf.setNullable;
+import static org.sonar.core.util.stream.MoreCollectors.uniqueIndex;
/**
* Add details about active rules to api/rules/search and api/rules/show
@ServerSide
public class ActiveRuleCompleter {
- private static final Logger LOG = Loggers.get(ActiveRuleCompleter.class);
-
private final DbClient dbClient;
private final Languages languages;
}
void completeSearch(DbSession dbSession, RuleQuery query, List<RuleDto> rules, SearchResponse.Builder searchResponse) {
- Collection<String> harvestedProfileKeys = writeActiveRules(dbSession, searchResponse, query, rules);
- searchResponse.setQProfiles(buildQProfiles(dbSession, harvestedProfileKeys));
+ Set<String> profileUuids = writeActiveRules(dbSession, searchResponse, query, rules);
+ searchResponse.setQProfiles(buildQProfiles(dbSession, profileUuids));
}
- private Collection<String> writeActiveRules(DbSession dbSession, SearchResponse.Builder response, RuleQuery query, List<RuleDto> rules) {
- Collection<String> qProfileKeys = new HashSet<>();
+ private Set<String> writeActiveRules(DbSession dbSession, SearchResponse.Builder response, RuleQuery query, List<RuleDto> rules) {
+ final Set<String> profileUuids = new HashSet<>();
Rules.Actives.Builder activesBuilder = response.getActivesBuilder();
- String profileKey = query.getQProfileKey();
- if (profileKey != null) {
+ QProfileDto profile = query.getQProfile();
+ if (profile != null) {
// Load details of active rules on the selected profile
- List<ActiveRuleDto> activeRuleDtos = dbClient.activeRuleDao().selectByProfileKey(dbSession, profileKey);
- Map<RuleKey, ActiveRuleDto> activeRuleByRuleKey = activeRuleDtos.stream().collect(MoreCollectors.uniqueIndex(d -> d.getKey().ruleKey()));
- ListMultimap<ActiveRuleKey, ActiveRuleParamDto> activeRuleParamsByActiveRuleKey = activeRuleDtosToActiveRuleParamDtos(dbSession, activeRuleDtos);
+ List<OrgActiveRuleDto> activeRules = dbClient.activeRuleDao().selectByProfile(dbSession, profile);
+ Map<RuleKey, OrgActiveRuleDto> activeRuleByRuleKey = activeRules.stream()
+ .collect(uniqueIndex(ActiveRuleDto::getRuleKey));
+ ListMultimap<ActiveRuleKey, ActiveRuleParamDto> activeRuleParamsByActiveRuleKey = loadParams(dbSession, activeRules);
for (RuleDto rule : rules) {
- ActiveRuleDto activeRule = activeRuleByRuleKey.get(rule.getKey());
+ OrgActiveRuleDto activeRule = activeRuleByRuleKey.get(rule.getKey());
if (activeRule != null) {
- qProfileKeys = writeActiveRules(rule.getKey(), singletonList(activeRule), activeRuleParamsByActiveRuleKey, activesBuilder);
+ profileUuids.addAll(writeActiveRules(rule.getKey(), singletonList(activeRule), activeRuleParamsByActiveRuleKey, activesBuilder));
}
}
} else {
// Load details of all active rules
- List<ActiveRuleDto> activeRuleDtos = dbClient.activeRuleDao().selectByRuleIds(dbSession, query.getOrganizationUuid(), Lists.transform(rules, RuleDto::getId));
- Multimap<RuleKey, ActiveRuleDto> activeRulesByRuleKey = from(activeRuleDtos).index(d -> d.getKey().ruleKey());
- ListMultimap<ActiveRuleKey, ActiveRuleParamDto> activeRuleParamsByActiveRuleKey = activeRuleDtosToActiveRuleParamDtos(dbSession, activeRuleDtos);
+ List<Integer> ruleIds = Lists.transform(rules, RuleDto::getId);
+ List<OrgActiveRuleDto> activeRules = dbClient.activeRuleDao().selectByRuleIds(dbSession, query.getOrganization(), ruleIds);
+ Multimap<RuleKey, OrgActiveRuleDto> activeRulesByRuleKey = activeRules.stream()
+ .collect(MoreCollectors.index(OrgActiveRuleDto::getRuleKey));
+ ListMultimap<ActiveRuleKey, ActiveRuleParamDto> activeRuleParamsByActiveRuleKey = loadParams(dbSession, activeRules);
+ rules.forEach(rule -> {
+ });
for (RuleDto rule : rules) {
- qProfileKeys = writeActiveRules(rule.getKey(), activeRulesByRuleKey.get(rule.getKey()), activeRuleParamsByActiveRuleKey, activesBuilder);
+ profileUuids.addAll(writeActiveRules(rule.getKey(), activeRulesByRuleKey.get(rule.getKey()), activeRuleParamsByActiveRuleKey, activesBuilder));
}
}
response.setActives(activesBuilder);
- return qProfileKeys;
+ return profileUuids;
}
- private static Collection<String> writeActiveRules(RuleKey ruleKey, Collection<ActiveRuleDto> activeRules,
+ private static Set<String> writeActiveRules(RuleKey ruleKey, Collection<OrgActiveRuleDto> activeRules,
ListMultimap<ActiveRuleKey, ActiveRuleParamDto> activeRuleParamsByActiveRuleKey, Rules.Actives.Builder activesBuilder) {
- Collection<String> qProfileKeys = newHashSet();
+ final Set<String> profileUuids = new HashSet<>();
Rules.ActiveList.Builder activeRulesListResponse = Rules.ActiveList.newBuilder();
- for (ActiveRuleDto activeRule : activeRules) {
+ for (OrgActiveRuleDto activeRule : activeRules) {
activeRulesListResponse.addActiveList(buildActiveRuleResponse(activeRule, activeRuleParamsByActiveRuleKey.get(activeRule.getKey())));
- qProfileKeys.add(activeRule.getKey().qProfile());
+ profileUuids.add(activeRule.getProfileUuid());
}
activesBuilder
.getMutableActives()
.put(ruleKey.toString(), activeRulesListResponse.build());
- return qProfileKeys;
+ return profileUuids;
}
- private ListMultimap<ActiveRuleKey, ActiveRuleParamDto> activeRuleDtosToActiveRuleParamDtos(DbSession dbSession, List<ActiveRuleDto> activeRuleDtos) {
+ private ListMultimap<ActiveRuleKey, ActiveRuleParamDto> loadParams(DbSession dbSession, List<OrgActiveRuleDto> activeRules) {
Map<Integer, ActiveRuleKey> activeRuleIdsByKey = new HashMap<>();
- for (ActiveRuleDto activeRuleDto : activeRuleDtos) {
- activeRuleIdsByKey.put(activeRuleDto.getId(), activeRuleDto.getKey());
+ for (OrgActiveRuleDto activeRule : activeRules) {
+ activeRuleIdsByKey.put(activeRule.getId(), activeRule.getKey());
}
- List<ActiveRuleParamDto> activeRuleParamDtos = dbClient.activeRuleDao().selectParamsByActiveRuleIds(dbSession, Lists.transform(activeRuleDtos, ActiveRuleDto::getId));
- ListMultimap<ActiveRuleKey, ActiveRuleParamDto> activeRuleParamsByActiveRuleKey = ArrayListMultimap.create(activeRuleDtos.size(), 10);
- for (ActiveRuleParamDto activeRuleParamDto : activeRuleParamDtos) {
- ActiveRuleKey activeRuleKey = activeRuleIdsByKey.get(activeRuleParamDto.getActiveRuleId());
- activeRuleParamsByActiveRuleKey.put(activeRuleKey, activeRuleParamDto);
+ List<ActiveRuleParamDto> activeRuleParams = dbClient.activeRuleDao().selectParamsByActiveRuleIds(dbSession, Lists.transform(activeRules, ActiveRuleDto::getId));
+ ListMultimap<ActiveRuleKey, ActiveRuleParamDto> activeRuleParamsByActiveRuleKey = ArrayListMultimap.create(activeRules.size(), 10);
+ for (ActiveRuleParamDto activeRuleParam : activeRuleParams) {
+ ActiveRuleKey activeRuleKey = activeRuleIdsByKey.get(activeRuleParam.getActiveRuleId());
+ activeRuleParamsByActiveRuleKey.put(activeRuleKey, activeRuleParam);
}
return activeRuleParamsByActiveRuleKey;
}
List<Rules.Active> completeShow(DbSession dbSession, OrganizationDto organization, RuleDefinitionDto rule) {
- List<ActiveRuleDto> activeRuleDtos = dbClient.activeRuleDao().selectByRuleId(dbSession, organization, rule.getId());
+ List<OrgActiveRuleDto> activeRules = dbClient.activeRuleDao().selectByRuleId(dbSession, organization, rule.getId());
Map<Integer, ActiveRuleKey> activeRuleIdsByKey = new HashMap<>();
- for (ActiveRuleDto activeRuleDto : activeRuleDtos) {
+ for (OrgActiveRuleDto activeRuleDto : activeRules) {
activeRuleIdsByKey.put(activeRuleDto.getId(), activeRuleDto.getKey());
}
- List<Integer> activeRuleIds = activeRuleDtos.stream().map(ActiveRuleDto::getId).collect(Collectors.toList());
- List<ActiveRuleParamDto> activeRuleParamDtos = dbClient.activeRuleDao().selectParamsByActiveRuleIds(dbSession, activeRuleIds);
- ListMultimap<ActiveRuleKey, ActiveRuleParamDto> activeRuleParamsByActiveRuleKey = ArrayListMultimap.create(activeRuleDtos.size(), 10);
- for (ActiveRuleParamDto activeRuleParamDto : activeRuleParamDtos) {
+ List<Integer> activeRuleIds = activeRules.stream().map(ActiveRuleDto::getId).collect(Collectors.toList());
+ List<ActiveRuleParamDto> activeRuleParams = dbClient.activeRuleDao().selectParamsByActiveRuleIds(dbSession, activeRuleIds);
+ ListMultimap<ActiveRuleKey, ActiveRuleParamDto> activeRuleParamsByActiveRuleKey = ArrayListMultimap.create(activeRules.size(), 10);
+ for (ActiveRuleParamDto activeRuleParamDto : activeRuleParams) {
ActiveRuleKey activeRuleKey = activeRuleIdsByKey.get(activeRuleParamDto.getActiveRuleId());
activeRuleParamsByActiveRuleKey.put(activeRuleKey, activeRuleParamDto);
}
- return activeRuleDtos.stream()
+ return activeRules.stream()
.map(activeRule -> buildActiveRuleResponse(activeRule, activeRuleParamsByActiveRuleKey.get(activeRule.getKey())))
.collect(Collectors.toList());
}
- private static Rules.Active buildActiveRuleResponse(ActiveRuleDto activeRule, List<ActiveRuleParamDto> parameters) {
- Rules.Active.Builder activeRuleResponse = Rules.Active.newBuilder();
- activeRuleResponse.setQProfile(activeRule.getKey().qProfile());
+ private static Rules.Active buildActiveRuleResponse(
OrgActiveRuleDto activeRule, List<ActiveRuleParamDto> parameters) {
+ Rules.Active.Builder builder = Rules.Active.newBuilder();
+ builder.setQProfile(activeRule.getProfileUuid());
String inheritance = activeRule.getInheritance();
- activeRuleResponse.setInherit(inheritance != null ? inheritance : ActiveRule.Inheritance.NONE.name());
- activeRuleResponse.setSeverity(activeRule.getSeverityString());
- activeRuleResponse.setCreatedAt(DateUtils.formatDateTime(activeRule.getCreatedAt()));
+ builder.setInherit(inheritance != null ? inheritance : ActiveRule.Inheritance.NONE.name());
+ builder.setSeverity(activeRule.getSeverityString());
+ builder.setCreatedAt(DateUtils.formatDateTime(activeRule.getCreatedAt()));
Rules.Active.Param.Builder paramBuilder = Rules.Active.Param.newBuilder();
for (ActiveRuleParamDto parameter : parameters) {
- activeRuleResponse.addParams(paramBuilder.clear()
+ builder.addParams(paramBuilder.clear()
.setKey(parameter.getKey())
.setValue(nullToEmpty(parameter.getValue())));
}
- return activeRuleResponse.build();
+ return builder.build();
}
- private Rules.QProfiles.Builder buildQProfiles(DbSession dbSession, Collection<String> harvestedProfileKeys) {
- Map<String, QProfileDto> qProfilesByKey = new HashMap<>();
- for (String qProfileKey : harvestedProfileKeys) {
- if (!qProfilesByKey.containsKey(qProfileKey)) {
- QProfileDto profile = loadProfile(dbSession, qProfileKey);
- if (profile == null) {
- LOG.warn("Could not find quality profile with key " + qProfileKey);
- continue;
- }
- qProfilesByKey.put(qProfileKey, profile);
- String parentKee = profile.getParentKee();
- if (parentKee != null && !qProfilesByKey.containsKey(parentKee)) {
- qProfilesByKey.put(parentKee, loadProfile(dbSession, parentKee));
- }
- }
+ private Rules.QProfiles.Builder buildQProfiles(DbSession dbSession, Set<String> profileUuids) {
+ Rules.QProfiles.Builder result = Rules.QProfiles.newBuilder();
+ if (profileUuids.isEmpty()) {
+ return result;
}
- Rules.QProfiles.Builder qProfilesResponse = Rules.QProfiles.newBuilder();
- Map<String, Rules.QProfile> qProfilesMapResponse = qProfilesResponse.getMutableQProfiles();
- for (QProfileDto profile : qProfilesByKey.values()) {
- writeProfile(qProfilesMapResponse, profile);
+ // load profiles
+ Map<String, QProfileDto> profilesByUuid = dbClient.qualityProfileDao().selectByUuids(dbSession, new ArrayList<>(profileUuids))
+ .stream()
+ .collect(uniqueIndex(QProfileDto::getKee));
+
+ // load associated parents
+ List<String> parentUuids = profilesByUuid.values().stream()
+ .map(QProfileDto::getParentKee)
+ .filter(StringUtils::isNotEmpty)
+ .filter(uuid -> !profilesByUuid.containsKey(uuid))
+ .collect(MoreCollectors.toList());
+ if (!parentUuids.isEmpty()) {
+ dbClient.qualityProfileDao().selectByUuids(dbSession, parentUuids)
+ .forEach(p -> profilesByUuid.put(p.getKee(), p));
}
- return qProfilesResponse;
- }
+ Map<String, Rules.QProfile> qProfilesMapResponse = result.getMutableQProfiles();
+ profilesByUuid.values().forEach(p -> writeProfile(qProfilesMapResponse, p));
- @CheckForNull
- private QProfileDto loadProfile(DbSession dbSession, String qProfileKey) {
- return dbClient.qualityProfileDao().selectByUuid(dbSession, qProfileKey);
+ return result;
}
private void writeProfile(Map<String, Rules.QProfile> profilesResponse, QProfileDto profile) {
private void addProfiles(DbSession dbSession, OrganizationDto organization, JsonWriter json) {
json.name("qualityprofiles").beginArray();
- for (QProfileDto profile : dbClient.qualityProfileDao().selectAll(dbSession, organization)) {
+ for (QProfileDto profile : dbClient.qualityProfileDao().selectOrderedByOrganizationUuid(dbSession, organization)) {
if (languageIsSupported(profile)) {
json
.beginObject()
import com.google.common.collect.ImmutableList;
import java.util.Date;
import java.util.List;
-import java.util.Optional;
-import javax.annotation.CheckForNull;
import org.sonar.api.rule.RuleStatus;
import org.sonar.api.rules.RuleType;
import org.sonar.api.server.ServerSide;
Boolean activation = request.paramAsBoolean(PARAM_ACTIVATION);
query.setActivation(activation);
- String qualityProfileKey = request.param(PARAM_QPROFILE);
+ String profileUuid = request.param(PARAM_QPROFILE);
String organizationKey = request.param(PARAM_ORGANIZATION);
- String organizationUuid;
+ OrganizationDto organization;
List<String> languages;
- if (qualityProfileKey == null) {
- organizationUuid = wsSupport.getOrganizationByKey(dbSession, organizationKey).getUuid();
+ if (profileUuid == null) {
+ organization = wsSupport.getOrganizationByKey(dbSession, organizationKey);
languages = request.paramAsStrings(PARAM_LANGUAGES);
} else {
- QProfileDto qualityProfileOptional = dbClient.qualityProfileDao().selectByUuid(dbSession, qualityProfileKey);
- QProfileDto qualityProfile = WsUtils.checkFound(qualityProfileOptional, "The specified qualityProfile '%s' does not exist", qualityProfileKey);
- query.setQProfileKey(qualityProfileKey);
- languages = ImmutableList.of(qualityProfile.getLanguage());
- organizationUuid = qualityProfile.getOrganizationUuid();
+ QProfileDto profileOptional = dbClient.qualityProfileDao().selectByUuid(dbSession, profileUuid);
+ QProfileDto profile = WsUtils.checkFound(profileOptional, "The specified qualityProfile '%s' does not exist", profileUuid);
+ query.setQProfile(profile);
+ languages = ImmutableList.of(profile.getLanguage());
+ organization = WsUtils.checkFoundWithOptional(dbClient.organizationDao().selectByUuid(dbSession, profile.getOrganizationUuid()), "No organization with UUID ",
+ profile.getOrganizationUuid());
if (organizationKey != null) {
- Optional<OrganizationDto> organizationOptional = dbClient.organizationDao().selectByKey(dbSession, organizationKey);
- OrganizationDto organization = WsUtils.checkFoundWithOptional(organizationOptional, "No organization with key '%s'", organizationKey);
- if (!organizationUuid.equals(organization.getUuid())) {
- throw new IllegalArgumentException(format("The specified quality profile '%s' is not part of the specified organization '%s'", qualityProfileKey, organizationKey));
+ OrganizationDto inputOrganization = WsUtils.checkFoundWithOptional(dbClient.organizationDao().selectByKey(dbSession, organizationKey), "No organization with key '%s'",
+ organizationKey);
+ if (!organization.getUuid().equals(inputOrganization.getUuid())) {
+ throw new IllegalArgumentException(format("The specified quality profile '%s' is not part of the specified organization '%s'", profileUuid, organizationKey));
}
}
}
- query.setOrganizationUuid(organizationUuid);
+ query.setOrganization(organization);
query.setLanguages(languages);
query.setTags(request.paramAsStrings(PARAM_TAGS));
}
return query;
}
-
- @CheckForNull
- private QProfileDto getProfileByKey(DbSession dbSession, String key) {
- return dbClient.qualityProfileDao().selectByUuid(dbSession, key);
- }
-
}
List<RuleKey> ruleKeys = result.getIds();
// rule order is managed by ES
Map<RuleKey, RuleDto> rulesByRuleKey = Maps.uniqueIndex(
- dbClient.ruleDao().selectByKeys(dbSession, query.getOrganizationUuid(), ruleKeys), RuleDto::getKey);
+ dbClient.ruleDao().selectByKeys(dbSession, query.getOrganization(), ruleKeys), RuleDto::getKey);
List<RuleDto> rules = new ArrayList<>();
for (RuleKey ruleKey : ruleKeys) {
RuleDto rule = rulesByRuleKey.get(ruleKey);
metadataBuilder.getMutableQprofilesPerLanguage().put("js", ScannerReport.Metadata.QProfile.newBuilder().setKey("p1").setName("Sonar way").setLanguage("js").build());
reportReader.setMetadata(metadataBuilder.build());
- dbTester.qualityProfiles().insert(organization, p -> p.setLanguage("js").setKey("p1"));
+ dbTester.qualityProfiles().insert(organization, p -> p.setLanguage("js").setKee("p1"));
ComputationStep underTest = createStep(createCeTask(PROJECT_KEY, organization.getUuid()));
metadataBuilder.getMutableQprofilesPerLanguage().put("php", ScannerReport.Metadata.QProfile.newBuilder().setKey("phpInOrg2").setName("PHP way").setLanguage("php").build());
reportReader.setMetadata(metadataBuilder.build());
- dbTester.qualityProfiles().insert(organization1, p -> p.setLanguage("js").setKey("jsInOrg1"));
- dbTester.qualityProfiles().insert(organization2, p -> p.setLanguage("php").setKey("phpInOrg2"));
+ dbTester.qualityProfiles().insert(organization1, p -> p.setLanguage("js").setKee("jsInOrg1"));
+ dbTester.qualityProfiles().insert(organization2, p -> p.setLanguage("php").setKee("phpInOrg2"));
ComputationStep underTest = createStep(createCeTask(PROJECT_KEY, organization1.getUuid()));
public class UpdateQualityProfilesLastUsedDateStepTest {
static final long ANALYSIS_DATE = 1_123_456_789L;
private static final Component PROJECT = ReportComponent.DUMB_PROJECT;
- private QProfileDto sonarWayJava = newQualityProfileDto().setKey("sonar-way-java");
- private QProfileDto sonarWayPhp = newQualityProfileDto().setKey("sonar-way-php");
- private QProfileDto myQualityProfile = newQualityProfileDto().setKey("my-qp");
+ private QProfileDto sonarWayJava = newQualityProfileDto().setKee("sonar-way-java");
+ private QProfileDto sonarWayPhp = newQualityProfileDto().setKee("sonar-way-php");
+ private QProfileDto myQualityProfile = newQualityProfileDto().setKee("my-qp");
@Rule
public ExpectedException expectedException = ExpectedException.none();
@Test
public void ancestor_profiles_are_updated() throws Exception {
// Parent profiles should be updated
- QProfileDto rootProfile = newQualityProfileDto().setKey("root");
- QProfileDto parentProfile = newQualityProfileDto().setKey("parent").setParentKee(rootProfile.getKee());
+ QProfileDto rootProfile = newQualityProfileDto().setKee("root");
+ QProfileDto parentProfile = newQualityProfileDto().setKee("parent").setParentKee(rootProfile.getKee());
// Current profile => should be updated
- QProfileDto currentProfile = newQualityProfileDto().setKey("current").setParentKee(parentProfile.getKee());
+ QProfileDto currentProfile = newQualityProfileDto().setKee("current").setParentKee(parentProfile.getKee());
// Child of current profile => should not be updated
- QProfileDto childProfile = newQualityProfileDto().setKey("child").setParentKee(currentProfile.getKee());
+ QProfileDto childProfile = newQualityProfileDto().setKee("child").setParentKee(currentProfile.getKee());
qualityProfileDb.insert(rootProfile, parentProfile, currentProfile, childProfile);
measureRepository.addRawMeasure(1, QUALITY_PROFILES_KEY, Measure.newMeasureBuilder().create(toJson(currentProfile.getKee())));
@Test
public void fail_when_profile_is_linked_to_unknown_parent() throws Exception {
- QProfileDto currentProfile = newQualityProfileDto().setKey("current").setParentKee("unknown");
+ QProfileDto currentProfile = newQualityProfileDto().setKee("current").setParentKee("unknown");
qualityProfileDb.insert(currentProfile);
measureRepository.addRawMeasure(1, QUALITY_PROFILES_KEY, Measure.newMeasureBuilder().create(toJson(currentProfile.getKee())));
*/
public <E extends BaseDoc> List<E> getDocuments(IndexType indexType, final Class<E> docClass) {
List<SearchHit> hits = getDocuments(indexType);
- return newArrayList(Collections2.transform(hits, new Function<SearchHit, E>() {
- @Override
- public E apply(SearchHit input) {
- try {
- return (E) ConstructorUtils.invokeConstructor(docClass, input.getSource());
- } catch (Exception e) {
- throw Throwables.propagate(e);
- }
+ return newArrayList(Collections2.transform(hits, input -> {
+ try {
+ return (E) ConstructorUtils.invokeConstructor(docClass, input.getSource());
+ } catch (Exception e) {
+ throw Throwables.propagate(e);
}
}));
}
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2017 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+package org.sonar.server.issue.index;
+
+import com.google.common.base.Function;
+import com.google.common.collect.Maps;
+import java.util.Map;
+import org.junit.Rule;
+import org.junit.Test;
+import org.sonar.api.rule.RuleKey;
+import org.sonar.api.utils.System2;
+import org.sonar.db.DbTester;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class IssueIteratorFactoryTest {
+
+ @Rule
+ public DbTester dbTester = DbTester.create(System2.INSTANCE);
+
+ @Test
+ public void iterator_over_one_issue() {
+ dbTester.prepareDbUnit(getClass(), "one_issue.xml");
+ Map<String, IssueDoc> issuesByKey = issuesByKey();
+
+ assertThat(issuesByKey).hasSize(1);
+
+ IssueDoc issue = issuesByKey.get("ABC");
+ assertThat(issue.key()).isEqualTo("ABC");
+ assertThat(issue.resolution()).isEqualTo("FIXED");
+ assertThat(issue.status()).isEqualTo("RESOLVED");
+ assertThat(issue.severity()).isEqualTo("BLOCKER");
+ assertThat(issue.isManualSeverity()).isFalse();
+ assertThat(issue.assignee()).isEqualTo("guy1");
+ assertThat(issue.authorLogin()).isEqualTo("guy2");
+ assertThat(issue.checksum()).isEqualTo("FFFFF");
+ assertThat(issue.line()).isEqualTo(444);
+ assertThat(issue.ruleKey()).isEqualTo(RuleKey.of("squid", "AvoidCycles"));
+ assertThat(issue.componentUuid()).isEqualTo("FILE1");
+ assertThat(issue.projectUuid()).isEqualTo("PROJECT1");
+ assertThat(issue.moduleUuid()).isEqualTo("PROJECT1");
+ assertThat(issue.modulePath()).isEqualTo(".PROJECT1.");
+ assertThat(issue.directoryPath()).isEqualTo("src/main/java");
+ assertThat(issue.filePath()).isEqualTo("src/main/java/Action.java");
+ assertThat(issue.tags()).containsOnly("tag1", "tag2", "tag3");
+ assertThat(issue.effort().toMinutes()).isGreaterThan(0L);
+ assertThat(issue.gap()).isEqualTo(2d);
+ assertThat(issue.attribute("JIRA")).isEqualTo("http://jira.com");
+ assertThat(issue.type().getDbConstant()).isEqualTo(2);
+ }
+
+ @Test
+ public void iterator_over_issues() {
+ dbTester.prepareDbUnit(getClass(), "shared.xml");
+ Map<String, IssueDoc> issuesByKey = issuesByKey();
+
+ assertThat(issuesByKey).hasSize(4);
+
+ IssueDoc issue = issuesByKey.get("ABC");
+ assertThat(issue.key()).isEqualTo("ABC");
+ assertThat(issue.assignee()).isEqualTo("guy1");
+ assertThat(issue.componentUuid()).isEqualTo("FILE1");
+ assertThat(issue.projectUuid()).isEqualTo("PROJECT1");
+ assertThat(issue.moduleUuid()).isEqualTo("PROJECT1");
+ assertThat(issue.modulePath()).isEqualTo(".PROJECT1.");
+ assertThat(issue.directoryPath()).isEqualTo("src/main/java");
+ assertThat(issue.filePath()).isEqualTo("src/main/java/Action.java");
+ assertThat(issue.tags()).containsOnly("tag1", "tag2", "tag3");
+ assertThat(issue.effort().toMinutes()).isGreaterThan(0L);
+ assertThat(issue.type().getDbConstant()).isEqualTo(1);
+
+ issue = issuesByKey.get("BCD");
+ assertThat(issue.key()).isEqualTo("BCD");
+ assertThat(issue.assignee()).isEqualTo("guy1");
+ assertThat(issue.componentUuid()).isEqualTo("MODULE1");
+ assertThat(issue.projectUuid()).isEqualTo("PROJECT1");
+ assertThat(issue.moduleUuid()).isEqualTo("MODULE1");
+ assertThat(issue.modulePath()).isEqualTo(".PROJECT1.MODULE1.");
+ assertThat(issue.directoryPath()).isNull();
+ assertThat(issue.filePath()).isNull();
+ assertThat(issue.tags()).containsOnly("tag1", "tag2", "tag3");
+ assertThat(issue.effort().toMinutes()).isGreaterThan(0L);
+ assertThat(issue.type().getDbConstant()).isEqualTo(2);
+
+ issue = issuesByKey.get("DEF");
+ assertThat(issue.key()).isEqualTo("DEF");
+ assertThat(issue.assignee()).isEqualTo("guy2");
+ assertThat(issue.componentUuid()).isEqualTo("FILE1");
+ assertThat(issue.projectUuid()).isEqualTo("PROJECT1");
+ assertThat(issue.moduleUuid()).isEqualTo("PROJECT1");
+ assertThat(issue.modulePath()).isEqualTo(".PROJECT1.");
+ assertThat(issue.directoryPath()).isEqualTo("src/main/java");
+ assertThat(issue.filePath()).isEqualTo("src/main/java/Action.java");
+ assertThat(issue.tags()).isEmpty();
+ assertThat(issue.effort().toMinutes()).isGreaterThan(0L);
+ assertThat(issue.type().getDbConstant()).isEqualTo(1);
+
+ issue = issuesByKey.get("EFG");
+ assertThat(issue.key()).isEqualTo("EFG");
+ assertThat(issue.assignee()).isEqualTo("guy1");
+ assertThat(issue.componentUuid()).isEqualTo("DIR1");
+ assertThat(issue.projectUuid()).isEqualTo("PROJECT1");
+ assertThat(issue.moduleUuid()).isEqualTo("MODULE1");
+ assertThat(issue.modulePath()).isEqualTo(".PROJECT1.MODULE1.");
+ assertThat(issue.directoryPath()).isEqualTo("src/main/java");
+ assertThat(issue.filePath()).isEqualTo("src/main/java");
+ assertThat(issue.tags()).isEmpty();
+ assertThat(issue.effort().toMinutes()).isGreaterThan(0L);
+ assertThat(issue.type().getDbConstant()).isEqualTo(1);
+ }
+
+ @Test
+ public void iterator_over_issue_from_project() {
+ dbTester.prepareDbUnit(getClass(), "many_projects.xml");
+ Map<String, IssueDoc> issuesByKey = issuesByKey(factory -> factory.createForProject("THE_PROJECT_1"));
+
+ assertThat(issuesByKey).hasSize(2);
+ }
+
+ @Test
+ public void extract_directory_path() {
+ dbTester.prepareDbUnit(getClass(), "extract_directory_path.xml");
+ Map<String, IssueDoc> issuesByKey = issuesByKey();
+
+ assertThat(issuesByKey).hasSize(4);
+
+ // File in sub directoy
+ assertThat(issuesByKey.get("ABC").directoryPath()).isEqualTo("src/main/java");
+
+ // File in root directoy
+ assertThat(issuesByKey.get("DEF").directoryPath()).isEqualTo("/");
+
+ // Module
+ assertThat(issuesByKey.get("EFG").filePath()).isNull();
+
+ // Project
+ assertThat(issuesByKey.get("FGH").filePath()).isNull();
+ }
+
+ @Test
+ public void extract_file_path() {
+ dbTester.prepareDbUnit(getClass(), "extract_file_path.xml");
+ Map<String, IssueDoc> issuesByKey = issuesByKey();
+
+ assertThat(issuesByKey).hasSize(4);
+
+ // File in sub directoy
+ assertThat(issuesByKey.get("ABC").filePath()).isEqualTo("src/main/java/Action.java");
+
+ // File in root directoy
+ assertThat(issuesByKey.get("DEF").filePath()).isEqualTo("pom.xml");
+
+ // Module
+ assertThat(issuesByKey.get("EFG").filePath()).isNull();
+
+ // Project
+ assertThat(issuesByKey.get("FGH").filePath()).isNull();
+ }
+
+ private Map<String, IssueDoc> issuesByKey() {
+ return issuesByKey(IssueIteratorFactory::createForAll);
+ }
+
+ private Map<String, IssueDoc> issuesByKey(Function<IssueIteratorFactory, IssueIterator> function) {
+ try (IssueIterator it = function.apply(new IssueIteratorFactory(dbTester.getDbClient()))) {
+ return Maps.uniqueIndex(it, IssueDoc::key);
+ }
+ }
+}
+++ /dev/null
-/*
- * SonarQube
- * Copyright (C) 2009-2017 SonarSource SA
- * mailto:info AT sonarsource DOT com
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 3 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-package org.sonar.server.issue.index;
-
-import com.google.common.base.Function;
-import com.google.common.collect.Maps;
-import java.util.Map;
-import javax.annotation.Nonnull;
-import org.junit.Rule;
-import org.junit.Test;
-import org.sonar.api.rule.RuleKey;
-import org.sonar.api.utils.System2;
-import org.sonar.db.DbTester;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-public class IssueResultSetIteratorTest {
-
- @Rule
- public DbTester dbTester = DbTester.create(System2.INSTANCE);
-
- @Test
- public void iterator_over_one_issue() {
- dbTester.prepareDbUnit(getClass(), "one_issue.xml");
- Map<String, IssueDoc> issuesByKey = issuesByKey();
-
- assertThat(issuesByKey).hasSize(1);
-
- IssueDoc issue = issuesByKey.get("ABC");
- assertThat(issue.key()).isEqualTo("ABC");
- assertThat(issue.resolution()).isEqualTo("FIXED");
- assertThat(issue.status()).isEqualTo("RESOLVED");
- assertThat(issue.severity()).isEqualTo("BLOCKER");
- assertThat(issue.isManualSeverity()).isFalse();
- assertThat(issue.assignee()).isEqualTo("guy1");
- assertThat(issue.authorLogin()).isEqualTo("guy2");
- assertThat(issue.checksum()).isEqualTo("FFFFF");
- assertThat(issue.line()).isEqualTo(444);
- assertThat(issue.ruleKey()).isEqualTo(RuleKey.of("squid", "AvoidCycles"));
- assertThat(issue.componentUuid()).isEqualTo("FILE1");
- assertThat(issue.projectUuid()).isEqualTo("PROJECT1");
- assertThat(issue.moduleUuid()).isEqualTo("PROJECT1");
- assertThat(issue.modulePath()).isEqualTo(".PROJECT1.");
- assertThat(issue.directoryPath()).isEqualTo("src/main/java");
- assertThat(issue.filePath()).isEqualTo("src/main/java/Action.java");
- assertThat(issue.tags()).containsOnly("tag1", "tag2", "tag3");
- assertThat(issue.effort().toMinutes()).isGreaterThan(0L);
- assertThat(issue.gap()).isEqualTo(2d);
- assertThat(issue.attribute("JIRA")).isEqualTo("http://jira.com");
- assertThat(issue.type().getDbConstant()).isEqualTo(2);
- }
-
- @Test
- public void iterator_over_issues() {
- dbTester.prepareDbUnit(getClass(), "shared.xml");
- Map<String, IssueDoc> issuesByKey = issuesByKey();
-
- assertThat(issuesByKey).hasSize(4);
-
- IssueDoc issue = issuesByKey.get("ABC");
- assertThat(issue.key()).isEqualTo("ABC");
- assertThat(issue.assignee()).isEqualTo("guy1");
- assertThat(issue.componentUuid()).isEqualTo("FILE1");
- assertThat(issue.projectUuid()).isEqualTo("PROJECT1");
- assertThat(issue.moduleUuid()).isEqualTo("PROJECT1");
- assertThat(issue.modulePath()).isEqualTo(".PROJECT1.");
- assertThat(issue.directoryPath()).isEqualTo("src/main/java");
- assertThat(issue.filePath()).isEqualTo("src/main/java/Action.java");
- assertThat(issue.tags()).containsOnly("tag1", "tag2", "tag3");
- assertThat(issue.effort().toMinutes()).isGreaterThan(0L);
- assertThat(issue.type().getDbConstant()).isEqualTo(1);
-
- issue = issuesByKey.get("BCD");
- assertThat(issue.key()).isEqualTo("BCD");
- assertThat(issue.assignee()).isEqualTo("guy1");
- assertThat(issue.componentUuid()).isEqualTo("MODULE1");
- assertThat(issue.projectUuid()).isEqualTo("PROJECT1");
- assertThat(issue.moduleUuid()).isEqualTo("MODULE1");
- assertThat(issue.modulePath()).isEqualTo(".PROJECT1.MODULE1.");
- assertThat(issue.directoryPath()).isNull();
- assertThat(issue.filePath()).isNull();
- assertThat(issue.tags()).containsOnly("tag1", "tag2", "tag3");
- assertThat(issue.effort().toMinutes()).isGreaterThan(0L);
- assertThat(issue.type().getDbConstant()).isEqualTo(2);
-
- issue = issuesByKey.get("DEF");
- assertThat(issue.key()).isEqualTo("DEF");
- assertThat(issue.assignee()).isEqualTo("guy2");
- assertThat(issue.componentUuid()).isEqualTo("FILE1");
- assertThat(issue.projectUuid()).isEqualTo("PROJECT1");
- assertThat(issue.moduleUuid()).isEqualTo("PROJECT1");
- assertThat(issue.modulePath()).isEqualTo(".PROJECT1.");
- assertThat(issue.directoryPath()).isEqualTo("src/main/java");
- assertThat(issue.filePath()).isEqualTo("src/main/java/Action.java");
- assertThat(issue.tags()).isEmpty();
- assertThat(issue.effort().toMinutes()).isGreaterThan(0L);
- assertThat(issue.type().getDbConstant()).isEqualTo(1);
-
- issue = issuesByKey.get("EFG");
- assertThat(issue.key()).isEqualTo("EFG");
- assertThat(issue.assignee()).isEqualTo("guy1");
- assertThat(issue.componentUuid()).isEqualTo("DIR1");
- assertThat(issue.projectUuid()).isEqualTo("PROJECT1");
- assertThat(issue.moduleUuid()).isEqualTo("MODULE1");
- assertThat(issue.modulePath()).isEqualTo(".PROJECT1.MODULE1.");
- assertThat(issue.directoryPath()).isEqualTo("src/main/java");
- assertThat(issue.filePath()).isEqualTo("src/main/java");
- assertThat(issue.tags()).isEmpty();
- assertThat(issue.effort().toMinutes()).isGreaterThan(0L);
- assertThat(issue.type().getDbConstant()).isEqualTo(1);
- }
-
- @Test
- public void iterator_over_issue_from_project() {
- dbTester.prepareDbUnit(getClass(), "many_projects.xml");
- Map<String, IssueDoc> issuesByKey = issuesByKey(factory -> factory.createForProject("THE_PROJECT_1"));
-
- assertThat(issuesByKey).hasSize(2);
- }
-
- @Test
- public void extract_directory_path() {
- dbTester.prepareDbUnit(getClass(), "extract_directory_path.xml");
- Map<String, IssueDoc> issuesByKey = issuesByKey();
-
- assertThat(issuesByKey).hasSize(4);
-
- // File in sub directoy
- assertThat(issuesByKey.get("ABC").directoryPath()).isEqualTo("src/main/java");
-
- // File in root directoy
- assertThat(issuesByKey.get("DEF").directoryPath()).isEqualTo("/");
-
- // Module
- assertThat(issuesByKey.get("EFG").filePath()).isNull();
-
- // Project
- assertThat(issuesByKey.get("FGH").filePath()).isNull();
- }
-
- @Test
- public void extract_file_path() {
- dbTester.prepareDbUnit(getClass(), "extract_file_path.xml");
- Map<String, IssueDoc> issuesByKey = issuesByKey();
-
- assertThat(issuesByKey).hasSize(4);
-
- // File in sub directoy
- assertThat(issuesByKey.get("ABC").filePath()).isEqualTo("src/main/java/Action.java");
-
- // File in root directoy
- assertThat(issuesByKey.get("DEF").filePath()).isEqualTo("pom.xml");
-
- // Module
- assertThat(issuesByKey.get("EFG").filePath()).isNull();
-
- // Project
- assertThat(issuesByKey.get("FGH").filePath()).isNull();
- }
-
- private Map<String, IssueDoc> issuesByKey() {
- return issuesByKey(IssueIteratorFactory::createForAll);
- }
-
- private Map<String, IssueDoc> issuesByKey(Function<IssueIteratorFactory, IssueIterator> function) {
- try (IssueIterator it = function.apply(new IssueIteratorFactory(dbTester.getDbClient()))) {
- return Maps.uniqueIndex(it, new Function<IssueDoc, String>() {
- @Override
- public String apply(@Nonnull IssueDoc issue) {
- return issue.key();
- }
- });
- }
- }
-}
import java.util.Collections;
import java.util.List;
import java.util.Optional;
+import org.apache.commons.lang.RandomStringUtils;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.sonar.api.config.MapSettings;
-import org.sonar.api.rule.RuleKey;
import org.sonar.api.utils.System2;
+import org.sonar.api.utils.internal.TestSystem2;
import org.sonar.api.web.UserRole;
import org.sonar.core.config.CorePropertyDefinitions;
import org.sonar.core.permission.GlobalPermissions;
+import org.sonar.core.util.SequenceUuidFactory;
import org.sonar.core.util.UuidFactory;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import org.sonar.db.permission.template.PermissionTemplateCharacteristicDto;
import org.sonar.db.permission.template.PermissionTemplateDto;
import org.sonar.db.permission.template.PermissionTemplateGroupDto;
-import org.sonar.db.qualityprofile.ActiveRuleKey;
+import org.sonar.db.qualityprofile.QProfileDto;
+import org.sonar.db.qualityprofile.RulesProfileDto;
import org.sonar.db.user.GroupDto;
import org.sonar.db.user.UserDto;
import org.sonar.db.user.UserMembershipDto;
import org.sonar.db.user.UserMembershipQuery;
import org.sonar.server.es.EsTester;
import org.sonar.server.es.SearchOptions;
-import org.sonar.server.language.LanguageTesting;
-import org.sonar.server.qualityprofile.ActiveRuleChange;
import org.sonar.server.qualityprofile.BuiltInQProfile;
-import org.sonar.server.qualityprofile.BuiltInQProfileInsertRule;
import org.sonar.server.qualityprofile.BuiltInQProfileRepositoryRule;
-import org.sonar.server.qualityprofile.index.ActiveRuleIndexer;
+import org.sonar.server.qualityprofile.QProfileName;
import org.sonar.server.user.index.UserIndex;
import org.sonar.server.user.index.UserIndexDefinition;
import org.sonar.server.user.index.UserIndexer;
import static org.assertj.core.api.Assertions.tuple;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
+import static org.sonar.server.language.LanguageTesting.newLanguage;
import static org.sonar.server.organization.OrganizationCreation.NewOrganization.newOrganizationBuilder;
public class OrganizationCreationImplTest {
- private static final String SOME_UUID = "org-uuid";
- private static final long SOME_DATE = 12893434L;
+ private static final long A_DATE = 12893434L;
private static final String A_LOGIN = "a-login";
private static final String SLUG_OF_A_LOGIN = "slug-of-a-login";
private static final String STRING_64_CHARS = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
private static final String A_NAME = "a name";
- private static final int ANYONE_GROUP_ID = 0;
private OrganizationCreation.NewOrganization FULL_POPULATED_NEW_ORGANIZATION = newOrganizationBuilder()
.setName("a-name")
.setAvatarUrl("a-avatar")
.build();
- private System2 system2 = mock(System2.class);
+ private System2 system2 = new TestSystem2().setNow(A_DATE);
@Rule
- public DbTester dbTester = DbTester.create(system2);
+ public DbTester db = DbTester.create(system2);
@Rule
public EsTester es = new EsTester(new UserIndexDefinition(new MapSettings()));
@Rule
public ExpectedException expectedException = ExpectedException.none();
@Rule
public BuiltInQProfileRepositoryRule builtInQProfileRepositoryRule = new BuiltInQProfileRepositoryRule();
- @Rule
- public BuiltInQProfileInsertRule builtInQProfileCreationRule = new BuiltInQProfileInsertRule();
- private DbSession dbSession = dbTester.getSession();
+ private DbSession dbSession = db.getSession();
private IllegalArgumentException exceptionThrownByOrganizationValidation = new IllegalArgumentException("simulate IAE thrown by OrganizationValidation");
- private DbClient dbClient = dbTester.getDbClient();
- private UuidFactory uuidFactory = mock(UuidFactory.class);
+ private DbClient dbClient = db.getDbClient();
+ private UuidFactory uuidFactory = new SequenceUuidFactory();
private OrganizationValidation organizationValidation = mock(OrganizationValidation.class);
private MapSettings settings = new MapSettings();
private UserIndexer userIndexer = new UserIndexer(dbClient, es.client());
private UserIndex userIndex = new UserIndex(es.client());
private DefaultGroupCreator defaultGroupCreator = new DefaultGroupCreatorImpl(dbClient);
- private ActiveRuleIndexer activeRuleIndexer = mock(ActiveRuleIndexer.class);
private OrganizationCreationImpl underTest = new OrganizationCreationImpl(dbClient, system2, uuidFactory, organizationValidation, settings, userIndexer,
- builtInQProfileRepositoryRule, builtInQProfileCreationRule, defaultGroupCreator, activeRuleIndexer);
+ builtInQProfileRepositoryRule, defaultGroupCreator);
private UserDto someUser;
@Before
public void setUp() {
- someUser = dbTester.users().insertUser();
+ someUser = db.users().insertUser();
userIndexer.index(someUser.getLogin());
}
@Test
public void create_fails_with_ISE_if_BuiltInQProfileRepository_has_not_been_initialized() throws OrganizationCreation.KeyConflictException {
- mockForSuccessfulInsert(SOME_UUID, SOME_DATE);
-
expectedException.expect(IllegalStateException.class);
expectedException.expectMessage("initialize must be called first");
@Test
public void create_fails_with_KeyConflictException_if_org_with_key_in_NewOrganization_arg_already_exists_in_db() throws OrganizationCreation.KeyConflictException {
- dbTester.organizations().insertForKey(FULL_POPULATED_NEW_ORGANIZATION.getKey());
+ db.organizations().insertForKey(FULL_POPULATED_NEW_ORGANIZATION.getKey());
expectedException.expect(OrganizationCreation.KeyConflictException.class);
expectedException.expectMessage("Organization key '" + FULL_POPULATED_NEW_ORGANIZATION.getKey() + "' is already used");
@Test
public void create_creates_unguarded_organization_with_properties_from_NewOrganization_arg() throws OrganizationCreation.KeyConflictException {
- mockForSuccessfulInsert(SOME_UUID, SOME_DATE);
builtInQProfileRepositoryRule.initialize();
underTest.create(dbSession, someUser, FULL_POPULATED_NEW_ORGANIZATION);
OrganizationDto organization = dbClient.organizationDao().selectByKey(dbSession, FULL_POPULATED_NEW_ORGANIZATION.getKey()).get();
- assertThat(organization.getUuid()).isEqualTo(SOME_UUID);
+ assertThat(organization.getUuid()).isNotEmpty();
assertThat(organization.getKey()).isEqualTo(FULL_POPULATED_NEW_ORGANIZATION.getKey());
assertThat(organization.getName()).isEqualTo(FULL_POPULATED_NEW_ORGANIZATION.getName());
assertThat(organization.getDescription()).isEqualTo(FULL_POPULATED_NEW_ORGANIZATION.getDescription());
assertThat(organization.getAvatarUrl()).isEqualTo(FULL_POPULATED_NEW_ORGANIZATION.getAvatar());
assertThat(organization.isGuarded()).isFalse();
assertThat(organization.getUserId()).isNull();
- assertThat(organization.getCreatedAt()).isEqualTo(SOME_DATE);
- assertThat(organization.getUpdatedAt()).isEqualTo(SOME_DATE);
+ assertThat(organization.getCreatedAt()).isEqualTo(A_DATE);
+ assertThat(organization.getUpdatedAt()).isEqualTo(A_DATE);
}
@Test
public void create_creates_owners_group_with_all_permissions_for_new_organization_and_add_current_user_to_it() throws OrganizationCreation.KeyConflictException {
- UserDto user = dbTester.users().insertUser();
- mockForSuccessfulInsert(SOME_UUID, SOME_DATE);
+ UserDto user = db.users().insertUser();
builtInQProfileRepositoryRule.initialize();
underTest.create(dbSession, user, FULL_POPULATED_NEW_ORGANIZATION);
@Test
public void create_creates_members_group_and_add_current_user_to_it() throws OrganizationCreation.KeyConflictException {
- UserDto user = dbTester.users().insertUser();
- mockForSuccessfulInsert(SOME_UUID, SOME_DATE);
+ UserDto user = db.users().insertUser();
builtInQProfileRepositoryRule.initialize();
underTest.create(dbSession, user, FULL_POPULATED_NEW_ORGANIZATION);
@Test
public void create_does_not_require_description_url_and_avatar_to_be_non_null() throws OrganizationCreation.KeyConflictException {
- mockForSuccessfulInsert(SOME_UUID, SOME_DATE);
builtInQProfileRepositoryRule.initialize();
underTest.create(dbSession, someUser, newOrganizationBuilder()
@Test
public void create_creates_default_template_for_new_organization() throws OrganizationCreation.KeyConflictException {
- mockForSuccessfulInsert(SOME_UUID, SOME_DATE);
builtInQProfileRepositoryRule.initialize();
underTest.create(dbSession, someUser, FULL_POPULATED_NEW_ORGANIZATION);
@Test
public void create_add_current_user_as_member_of_organization() throws OrganizationCreation.KeyConflictException {
- UserDto user = dbTester.users().insertUser();
+ UserDto user = db.users().insertUser();
userIndexer.index(user.getLogin());
- mockForSuccessfulInsert(SOME_UUID, SOME_DATE);
builtInQProfileRepositoryRule.initialize();
userIndexer.index(someUser.getLogin());
- underTest.create(dbSession, someUser, FULL_POPULATED_NEW_ORGANIZATION);
+ OrganizationDto result = underTest.create(dbSession, someUser, FULL_POPULATED_NEW_ORGANIZATION);
- assertThat(dbClient.organizationMemberDao().select(dbSession, SOME_UUID, someUser.getId())).isPresent();
- assertThat(userIndex.search(UserQuery.builder().setOrganizationUuid(SOME_UUID).setTextQuery(someUser.getLogin()).build(), new SearchOptions()).getTotal()).isEqualTo(1L);
+ assertThat(dbClient.organizationMemberDao().select(dbSession, result.getUuid(), someUser.getId())).isPresent();
+ assertThat(userIndex.search(UserQuery.builder().setOrganizationUuid(result.getUuid()).setTextQuery(someUser.getLogin()).build(), new SearchOptions()).getTotal()).isEqualTo(1L);
}
@Test
- public void create_creates_QualityProfile_for_each_BuiltInQProfile_in_repository_and_index_ActiveRule_changes_in_order() throws OrganizationCreation.KeyConflictException {
- BuiltInQProfile builtInQProfile1 = builtInQProfileRepositoryRule.add(LanguageTesting.newLanguage("foo"), "qp1");
- BuiltInQProfile builtInQProfile2 = builtInQProfileRepositoryRule.add(LanguageTesting.newLanguage("foo"), "qp2");
- BuiltInQProfile builtInQProfile3 = builtInQProfileRepositoryRule.add(LanguageTesting.newLanguage("foo"), "qp3");
- BuiltInQProfile builtInQProfile4 = builtInQProfileRepositoryRule.add(LanguageTesting.newLanguage("foo"), "qp4");
+ public void create_associates_to_built_in_quality_profiles() throws OrganizationCreation.KeyConflictException {
+ BuiltInQProfile builtIn1 = builtInQProfileRepositoryRule.add(newLanguage("foo"), "qp1", true);
+ BuiltInQProfile builtIn2 = builtInQProfileRepositoryRule.add(newLanguage("foo"), "qp2");
builtInQProfileRepositoryRule.initialize();
- mockForSuccessfulInsert(SOME_UUID, SOME_DATE);
+ insertRulesProfile(builtIn1);
+ insertRulesProfile(builtIn2);
underTest.create(dbSession, someUser, FULL_POPULATED_NEW_ORGANIZATION);
OrganizationDto organization = dbClient.organizationDao().selectByKey(dbSession, FULL_POPULATED_NEW_ORGANIZATION.getKey()).get();
- assertThat(builtInQProfileCreationRule.getCallLogs())
- .hasSize(4)
- .extracting(BuiltInQProfileInsertRule.CallLog::getOrganizationDto)
- .extracting(OrganizationDto::getUuid)
- .containsOnly(organization.getUuid());
- assertThat(builtInQProfileCreationRule.getCallLogs())
- .extracting(BuiltInQProfileInsertRule.CallLog::getDefinedQProfile)
- .extracting(BuiltInQProfile::getName)
- .containsExactly(builtInQProfile1.getName(), builtInQProfile2.getName(), builtInQProfile3.getName(), builtInQProfile4.getName());
+ List<QProfileDto> profiles = dbClient.qualityProfileDao().selectOrderedByOrganizationUuid(dbSession, organization);
+ assertThat(profiles).extracting(p -> new QProfileName(p.getLanguage(), p.getName())).containsExactlyInAnyOrder(
+ builtIn1.getQProfileName(), builtIn2.getQProfileName());
+ assertThat(dbClient.qualityProfileDao().selectDefaultProfile(dbSession, organization, "foo").getName())
+ .isEqualTo("qp1");
+ }
+
+ private void insertRulesProfile(BuiltInQProfile builtIn) {
+ RulesProfileDto dto = new RulesProfileDto()
+ .setIsBuiltIn(true)
+ .setKee(RandomStringUtils.randomAlphabetic(40))
+ .setLanguage(builtIn.getLanguage())
+ .setName(builtIn.getName());
+ dbClient.qualityProfileDao().insert(db.getSession(), dto);
+ db.commit();
}
@Test
}
private void checkSizeOfTables() {
- assertThat(dbTester.countRowsOfTable("organizations")).isEqualTo(1);
- assertThat(dbTester.countRowsOfTable("groups")).isEqualTo(0);
- assertThat(dbTester.countRowsOfTable("groups_users")).isEqualTo(0);
- assertThat(dbTester.countRowsOfTable("permission_templates")).isEqualTo(0);
- assertThat(dbTester.countRowsOfTable("perm_templates_users")).isEqualTo(0);
- assertThat(dbTester.countRowsOfTable("perm_templates_groups")).isEqualTo(0);
+ assertThat(db.countRowsOfTable("organizations")).isEqualTo(1);
+ assertThat(db.countRowsOfTable("groups")).isEqualTo(0);
+ assertThat(db.countRowsOfTable("groups_users")).isEqualTo(0);
+ assertThat(db.countRowsOfTable("permission_templates")).isEqualTo(0);
+ assertThat(db.countRowsOfTable("perm_templates_users")).isEqualTo(0);
+ assertThat(db.countRowsOfTable("perm_templates_groups")).isEqualTo(0);
}
@Test
public void createForUser_creates_guarded_organization_with_key_name_and_description_generated_from_user_login_and_name_and_associated_to_user() {
- UserDto user = dbTester.users().insertUser(A_LOGIN);
+ UserDto user = db.users().insertUser(A_LOGIN);
when(organizationValidation.generateKeyFrom(A_LOGIN)).thenReturn(SLUG_OF_A_LOGIN);
- mockForSuccessfulInsert(SOME_UUID, SOME_DATE);
enableCreatePersonalOrg(true);
builtInQProfileRepositoryRule.initialize();
underTest.createForUser(dbSession, user);
OrganizationDto organization = dbClient.organizationDao().selectByKey(dbSession, SLUG_OF_A_LOGIN).get();
- assertThat(organization.getUuid()).isEqualTo(SOME_UUID);
+ assertThat(organization.getUuid()).isNotEmpty();
assertThat(organization.getKey()).isEqualTo(SLUG_OF_A_LOGIN);
assertThat(organization.getName()).isEqualTo(user.getName());
assertThat(organization.getDescription()).isEqualTo(user.getName() + "'s personal organization");
assertThat(organization.getAvatarUrl()).isNull();
assertThat(organization.isGuarded()).isTrue();
assertThat(organization.getUserId()).isEqualTo(user.getId());
- assertThat(organization.getCreatedAt()).isEqualTo(SOME_DATE);
- assertThat(organization.getUpdatedAt()).isEqualTo(SOME_DATE);
+ assertThat(organization.getCreatedAt()).isEqualTo(A_DATE);
+ assertThat(organization.getUpdatedAt()).isEqualTo(A_DATE);
}
@Test
public void createForUser_fails_with_ISE_if_organization_with_slug_of_login_already_exists() {
- UserDto user = dbTester.users().insertUser(A_LOGIN);
+ UserDto user = db.users().insertUser(A_LOGIN);
when(organizationValidation.generateKeyFrom(A_LOGIN)).thenReturn(SLUG_OF_A_LOGIN);
- dbTester.organizations().insertForKey(SLUG_OF_A_LOGIN);
- mockForSuccessfulInsert(SOME_UUID, SOME_DATE);
+ db.organizations().insertForKey(SLUG_OF_A_LOGIN);
enableCreatePersonalOrg(true);
expectedException.expect(IllegalStateException.class);
@Test
public void createForUser_gives_all_permissions_for_new_organization_to_current_user() throws OrganizationCreation.KeyConflictException {
- UserDto user = dbTester.users().insertUser(dto -> dto.setLogin(A_LOGIN).setName(A_NAME));
+ UserDto user = db.users().insertUser(dto -> dto.setLogin(A_LOGIN).setName(A_NAME));
when(organizationValidation.generateKeyFrom(A_LOGIN)).thenReturn(SLUG_OF_A_LOGIN);
- mockForSuccessfulInsert(SOME_UUID, SOME_DATE);
enableCreatePersonalOrg(true);
builtInQProfileRepositoryRule.initialize();
@Test
public void createForUser_creates_members_group_and_add_current_user_to_it() throws OrganizationCreation.KeyConflictException {
- UserDto user = dbTester.users().insertUser(dto -> dto.setLogin(A_LOGIN).setName(A_NAME));
+ UserDto user = db.users().insertUser(dto -> dto.setLogin(A_LOGIN).setName(A_NAME));
when(organizationValidation.generateKeyFrom(A_LOGIN)).thenReturn(SLUG_OF_A_LOGIN);
- mockForSuccessfulInsert(SOME_UUID, SOME_DATE);
enableCreatePersonalOrg(true);
builtInQProfileRepositoryRule.initialize();
@Test
public void createForUser_creates_default_template_for_new_organization() throws OrganizationCreation.KeyConflictException {
- UserDto user = dbTester.users().insertUser(dto -> dto.setLogin(A_LOGIN).setName(A_NAME));
+ UserDto user = db.users().insertUser(dto -> dto.setLogin(A_LOGIN).setName(A_NAME));
when(organizationValidation.generateKeyFrom(A_LOGIN)).thenReturn(SLUG_OF_A_LOGIN);
- mockForSuccessfulInsert(SOME_UUID, SOME_DATE);
enableCreatePersonalOrg(true);
builtInQProfileRepositoryRule.initialize();
@Test
public void createForUser_add_current_user_as_member_of_organization() throws OrganizationCreation.KeyConflictException {
- UserDto user = dbTester.users().insertUser(dto -> dto.setLogin(A_LOGIN).setName(A_NAME));
+ UserDto user = db.users().insertUser(dto -> dto.setLogin(A_LOGIN).setName(A_NAME));
when(organizationValidation.generateKeyFrom(A_LOGIN)).thenReturn(SLUG_OF_A_LOGIN);
- mockForSuccessfulInsert(SOME_UUID, SOME_DATE);
enableCreatePersonalOrg(true);
builtInQProfileRepositoryRule.initialize();
@Test
public void createForUser_does_not_fail_if_name_is_too_long_for_an_organization_name() {
String nameTooLong = STRING_64_CHARS + "b";
- UserDto user = dbTester.users().insertUser(dto -> dto.setName(nameTooLong).setLogin(A_LOGIN));
+ UserDto user = db.users().insertUser(dto -> dto.setName(nameTooLong).setLogin(A_LOGIN));
when(organizationValidation.generateKeyFrom(A_LOGIN)).thenReturn(SLUG_OF_A_LOGIN);
- mockForSuccessfulInsert(SOME_UUID, SOME_DATE);
enableCreatePersonalOrg(true);
builtInQProfileRepositoryRule.initialize();
@Test
public void createForUser_does_not_fail_if_name_is_empty_and_login_is_too_long_for_an_organization_name() {
String login = STRING_64_CHARS + "b";
- UserDto user = dbTester.users().insertUser(dto -> dto.setName("").setLogin(login));
+ UserDto user = db.users().insertUser(dto -> dto.setName("").setLogin(login));
when(organizationValidation.generateKeyFrom(login)).thenReturn(SLUG_OF_A_LOGIN);
- mockForSuccessfulInsert(SOME_UUID, SOME_DATE);
enableCreatePersonalOrg(true);
builtInQProfileRepositoryRule.initialize();
@Test
public void createForUser_does_not_fail_if_name_is_null_and_login_is_too_long_for_an_organization_name() {
String login = STRING_64_CHARS + "b";
- UserDto user = dbTester.users().insertUser(dto -> dto.setName(null).setLogin(login));
+ UserDto user = db.users().insertUser(dto -> dto.setName(null).setLogin(login));
when(organizationValidation.generateKeyFrom(login)).thenReturn(SLUG_OF_A_LOGIN);
- mockForSuccessfulInsert(SOME_UUID, SOME_DATE);
enableCreatePersonalOrg(true);
builtInQProfileRepositoryRule.initialize();
}
@Test
- public void createForUser_creates_QualityProfile_for_each_DefinedQProfile_in_repository_and_index_ActiveRule_changes_in_order() throws OrganizationCreation.KeyConflictException {
- UserDto user = dbTester.users().insertUser(A_LOGIN);
+ public void createForUser_associates_to_built_in_quality_profiles() throws OrganizationCreation.KeyConflictException {
+ UserDto user = db.users().insertUser(A_LOGIN);
when(organizationValidation.generateKeyFrom(A_LOGIN)).thenReturn(SLUG_OF_A_LOGIN);
- BuiltInQProfile builtInQProfile1 = builtInQProfileRepositoryRule.add(LanguageTesting.newLanguage("foo"), "qp1");
- BuiltInQProfile builtInQProfile2 = builtInQProfileRepositoryRule.add(LanguageTesting.newLanguage("foo"), "qp2");
- BuiltInQProfile builtInQProfile3 = builtInQProfileRepositoryRule.add(LanguageTesting.newLanguage("foo"), "qp3");
- BuiltInQProfile builtInQProfile4 = builtInQProfileRepositoryRule.add(LanguageTesting.newLanguage("foo"), "qp4");
- builtInQProfileRepositoryRule.initialize();
- mockForSuccessfulInsert(SOME_UUID, SOME_DATE);
enableCreatePersonalOrg(true);
+ BuiltInQProfile builtIn1 = builtInQProfileRepositoryRule.add(newLanguage("foo"), "qp1");
+ BuiltInQProfile builtIn2 = builtInQProfileRepositoryRule.add(newLanguage("foo"), "qp2");
+ builtInQProfileRepositoryRule.initialize();
+ insertRulesProfile(builtIn1);
+ insertRulesProfile(builtIn2);
+
underTest.createForUser(dbSession, user);
OrganizationDto organization = dbClient.organizationDao().selectByKey(dbSession, SLUG_OF_A_LOGIN).get();
- assertThat(builtInQProfileCreationRule.getCallLogs())
- .hasSize(4)
- .extracting(BuiltInQProfileInsertRule.CallLog::getOrganizationDto)
- .extracting(OrganizationDto::getUuid)
- .containsOnly(organization.getUuid());
- assertThat(builtInQProfileCreationRule.getCallLogs())
- .extracting(BuiltInQProfileInsertRule.CallLog::getDefinedQProfile)
- .extracting(BuiltInQProfile::getName)
- .containsExactly(builtInQProfile1.getName(), builtInQProfile2.getName(), builtInQProfile3.getName(), builtInQProfile4.getName());
- }
-
- private static ActiveRuleChange newActiveRuleChange(String id) {
- return ActiveRuleChange.createFor(ActiveRuleChange.Type.ACTIVATED, ActiveRuleKey.of(id, RuleKey.of(id + "1", id + "2")));
+ List<QProfileDto> profiles = dbClient.qualityProfileDao().selectOrderedByOrganizationUuid(dbSession, organization);
+ assertThat(profiles).extracting(p -> new QProfileName(p.getLanguage(), p.getName())).containsExactlyInAnyOrder(
+ builtIn1.getQProfileName(), builtIn2.getQProfileName());
}
private void enableCreatePersonalOrg(boolean flag) {
settings.setProperty(CorePropertyDefinitions.ORGANIZATIONS_CREATE_PERSONAL_ORG, flag);
}
- private void mockForSuccessfulInsert(String orgUuid, long orgDate) {
- when(uuidFactory.create()).thenReturn(orgUuid);
- when(system2.now()).thenReturn(orgDate);
- }
-
private void verifyGroupOwners(UserDto user, String organizationKey, String organizationName) {
OrganizationDto organization = dbClient.organizationDao().selectByKey(dbSession, organizationKey).get();
Optional<GroupDto> groupOpt = dbClient.groupDao().selectByName(dbSession, organization.getUuid(), "Owners");
import org.sonar.server.organization.OrganizationValidation;
import org.sonar.server.organization.OrganizationValidationImpl;
import org.sonar.server.organization.TestOrganizationFlags;
-import org.sonar.server.qualityprofile.BuiltInQProfileInsert;
import org.sonar.server.qualityprofile.BuiltInQProfileRepository;
import org.sonar.server.qualityprofile.index.ActiveRuleIndexer;
import org.sonar.server.tester.UserSessionRule;
private OrganizationValidation organizationValidation = new OrganizationValidationImpl();
private UserIndexer userIndexer = new UserIndexer(dbClient, es.client());
private UserIndex userIndex = new UserIndex(es.client());
- private ActiveRuleIndexer activeRuleIndexer = mock(ActiveRuleIndexer.class);
private OrganizationCreation organizationCreation = new OrganizationCreationImpl(dbClient, system2, uuidFactory, organizationValidation, settings, userIndexer,
- mock(BuiltInQProfileRepository.class), mock(BuiltInQProfileInsert.class), new DefaultGroupCreatorImpl(dbClient), activeRuleIndexer);
+ mock(BuiltInQProfileRepository.class), new DefaultGroupCreatorImpl(dbClient));
private TestOrganizationFlags organizationFlags = TestOrganizationFlags.standalone().setEnabled(true);
private UserDto user;
sendRequest(org);
verifyOrganizationDoesNotExist(org);
- assertThat(db.select("select kee as \"profileKey\" from rules_profiles"))
+ assertThat(db.select("select uuid as \"profileKey\" from org_qprofiles"))
.extracting(row -> (String) row.get("profileKey"))
.containsOnly(profileInOtherOrg.getKee());
}
import org.sonar.api.rule.RuleKey;
import org.sonar.db.qualityprofile.ActiveRuleKey;
import org.sonar.db.qualityprofile.QProfileChangeDto;
+import org.sonar.db.qualityprofile.QProfileDto;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.sonar.db.qualityprofile.QualityProfileTesting.newQualityProfileDto;
import static org.sonar.server.qualityprofile.ActiveRuleChange.Type.ACTIVATED;
public class ActiveRuleChangeTest {
- private static final String MY_LOGIN = "MY_LOGIN";
-
- private ActiveRuleChange underTest = ActiveRuleChange.createFor(ACTIVATED, ActiveRuleKey.of("QP1", RuleKey.of("P1", "R1")));
+ private static final String A_LOGIN = "A_LOGIN";
@Test
- public void to_dto() {
- QProfileChangeDto result = underTest.toDto(MY_LOGIN);
+ public void toDto() {
+ QProfileDto profile = newQualityProfileDto();
+ ActiveRuleKey key = ActiveRuleKey.of(profile, RuleKey.of("P1", "R1"));
+ ActiveRuleChange underTest = new ActiveRuleChange(ACTIVATED, key);
+
+ QProfileChangeDto result = underTest.toDto(A_LOGIN);
assertThat(result.getChangeType()).isEqualTo(ACTIVATED.name());
- assertThat(result.getProfileKey()).isEqualTo("QP1");
- assertThat(result.getLogin()).isEqualTo(MY_LOGIN);
+ assertThat(result.getRulesProfileUuid()).isEqualTo(profile.getRulesProfileUuid());
+ assertThat(result.getLogin()).isEqualTo(A_LOGIN);
}
}
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2017 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+package org.sonar.server.qualityprofile;
+
+import java.util.List;
+import org.junit.After;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.sonar.api.profiles.RulesProfile;
+import org.sonar.api.rule.Severity;
+import org.sonar.api.rules.RulePriority;
+import org.sonar.api.utils.System2;
+import org.sonar.api.utils.internal.AlwaysIncreasingSystem2;
+import org.sonar.core.util.SequenceUuidFactory;
+import org.sonar.core.util.UuidFactory;
+import org.sonar.db.DbSession;
+import org.sonar.db.DbTester;
+import org.sonar.db.organization.OrganizationDto;
+import org.sonar.db.qualityprofile.ActiveRuleDto;
+import org.sonar.db.qualityprofile.ActiveRuleKey;
+import org.sonar.db.qualityprofile.ActiveRuleParamDto;
+import org.sonar.db.qualityprofile.QProfileChangeDto;
+import org.sonar.db.qualityprofile.QProfileChangeQuery;
+import org.sonar.db.qualityprofile.QProfileDto;
+import org.sonar.db.rule.RuleDefinitionDto;
+import org.sonar.server.language.LanguageTesting;
+import org.sonar.server.qualityprofile.index.ActiveRuleIndexer;
+import org.sonar.server.util.TypeValidations;
+
+import static java.util.Collections.emptyList;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.sonar.api.rules.RulePriority.CRITICAL;
+import static org.sonar.api.rules.RulePriority.MAJOR;
+
+public class BuiltInQProfileInsertImplTest {
+
+ @Rule
+ public BuiltInQProfileRepositoryRule builtInQProfileRepository = new BuiltInQProfileRepositoryRule();
+ @Rule
+ public DbTester db = DbTester.create().setDisableDefaultOrganization(true);
+ @Rule
+ public ExpectedException expectedException = ExpectedException.none();
+
+ private System2 system2 = new AlwaysIncreasingSystem2();
+ private UuidFactory uuidFactory = new SequenceUuidFactory();
+ private TypeValidations typeValidations = new TypeValidations(emptyList());
+ private DbSession dbSession = db.getSession();
+ private DbSession batchDbSession = db.getDbClient().openSession(true);
+ private ActiveRuleIndexer activeRuleIndexer = mock(ActiveRuleIndexer.class);
+ private BuiltInQProfileInsertImpl underTest = new BuiltInQProfileInsertImpl(db.getDbClient(), system2, uuidFactory, typeValidations, activeRuleIndexer);
+
+ @After
+ public void tearDown() {
+ batchDbSession.close();
+ }
+
+ @Test
+ public void insert_single_row_in_RULES_PROFILES_and_reference_it_in_ORG_QPROFILES() {
+ OrganizationDto org1 = db.organizations().insert();
+ OrganizationDto org2 = db.organizations().insert();
+ BuiltInQProfile builtIn = builtInQProfileRepository.create(LanguageTesting.newLanguage("xoo"), "the name", false);
+
+ call(builtIn);
+
+ verifyTableSize("org_qprofiles", 2);
+ verifyTableSize("rules_profiles", 1);
+ verifyTableSize("active_rules", 0);
+ verifyTableSize("active_rule_parameters", 0);
+ verifyTableSize("qprofile_changes", 0);
+ verifyTableSize("project_qprofiles", 0);
+
+ QProfileDto profileOnOrg1 = verifyProfileInDb(org1, builtIn);
+ QProfileDto profileOnOrg2 = verifyProfileInDb(org2, builtIn);
+
+ // same row in table rules_profiles is used
+ assertThat(profileOnOrg1.getKee()).isNotEqualTo(profileOnOrg2.getKee());
+ assertThat(profileOnOrg1.getRulesProfileUuid()).isEqualTo(profileOnOrg2.getRulesProfileUuid());
+ assertThat(profileOnOrg1.getId()).isEqualTo(profileOnOrg2.getId());
+ }
+
+ @Test
+ public void insert_active_rules_and_changelog() {
+ OrganizationDto org = db.organizations().insert();
+ RuleDefinitionDto rule1 = db.rules().insert(r -> r.setLanguage("xoo"));
+ RuleDefinitionDto rule2 = db.rules().insert(r -> r.setLanguage("xoo"));
+ RulesProfile apiProfile = RulesProfile.create("the name", "xoo");
+ activeRule(apiProfile, rule1, CRITICAL);
+ activeRule(apiProfile, rule2, MAJOR);
+
+ BuiltInQProfile builtIn = builtInQProfileRepository.create(apiProfile);
+ call(builtIn);
+
+ verifyTableSize("rules_profiles", 1);
+ verifyTableSize("active_rules", 2);
+ verifyTableSize("active_rule_parameters", 0);
+ verifyTableSize("qprofile_changes", 2);
+
+ QProfileDto profile = verifyProfileInDb(org, builtIn);
+ verifyActiveRuleInDb(profile, rule1, Severity.CRITICAL);
+ verifyActiveRuleInDb(profile, rule2, Severity.MAJOR);
+ }
+
+ @Test
+ public void flag_profile_as_default_on_organizations_if_declared_as_default_by_api() {
+ OrganizationDto org = db.organizations().insert();
+ RulesProfile apiProfile = RulesProfile.create("the name", "xoo");
+ apiProfile.setDefaultProfile(true);
+ BuiltInQProfile builtIn = builtInQProfileRepository.create(apiProfile);
+
+ call(builtIn);
+
+ QProfileDto profile = verifyProfileInDb(org, builtIn);
+ QProfileDto defaultProfile = db.getDbClient().qualityProfileDao().selectDefaultProfile(dbSession, org, "xoo");
+ assertThat(defaultProfile.getKee()).isEqualTo(profile.getKee());
+ }
+
+ @Test
+ public void dont_flag_profile_as_default_on_organizations_if_not_declared_as_default_by_api() {
+ OrganizationDto org = db.organizations().insert();
+ RulesProfile apiProfile = RulesProfile.create("the name", "xoo");
+ apiProfile.setDefaultProfile(false);
+ BuiltInQProfile builtIn = builtInQProfileRepository.create(apiProfile);
+
+ call(builtIn);
+
+ QProfileDto defaultProfile = db.getDbClient().qualityProfileDao().selectDefaultProfile(dbSession, org, "xoo");
+ assertThat(defaultProfile).isNull();
+ }
+
+ // TODO test params
+ // TODO test lot of active_rules, params, orgas
+
+ private void verifyActiveRuleInDb(QProfileDto profile, RuleDefinitionDto rule, String expectedSeverity) {
+ ActiveRuleDto activeRule = db.getDbClient().activeRuleDao().selectByKey(dbSession, ActiveRuleKey.of(profile, rule.getKey())).get();
+ assertThat(activeRule.getId()).isPositive();
+ assertThat(activeRule.getInheritance()).isNull();
+ assertThat(activeRule.doesOverride()).isFalse();
+ assertThat(activeRule.getRuleId()).isEqualTo(rule.getId());
+ assertThat(activeRule.getProfileId()).isEqualTo(profile.getId());
+ assertThat(activeRule.getSeverityString()).isEqualTo(expectedSeverity);
+ assertThat(activeRule.getCreatedAt()).isPositive();
+ assertThat(activeRule.getUpdatedAt()).isPositive();
+
+ List<ActiveRuleParamDto> params = db.getDbClient().activeRuleDao().selectParamsByActiveRuleId(dbSession, activeRule.getId());
+ assertThat(params).isEmpty();
+
+ QProfileChangeQuery changeQuery = new QProfileChangeQuery(profile.getKee());
+ QProfileChangeDto change = db.getDbClient().qProfileChangeDao().selectByQuery(dbSession, changeQuery).stream()
+ .filter(c -> c.getDataAsMap().get("ruleKey").equals(rule.getKey().toString()))
+ .findFirst()
+ .get();
+ assertThat(change.getChangeType()).isEqualTo(ActiveRuleChange.Type.ACTIVATED.name());
+ assertThat(change.getCreatedAt()).isPositive();
+ assertThat(change.getUuid()).isNotEmpty();
+ assertThat(change.getLogin()).isNull();
+ assertThat(change.getRulesProfileUuid()).isEqualTo(profile.getRulesProfileUuid());
+ assertThat(change.getDataAsMap().get("severity")).isEqualTo(expectedSeverity);
+ }
+
+ private static void activeRule(RulesProfile apiProfile, RuleDefinitionDto rule, RulePriority severity) {
+ apiProfile.activateRule(org.sonar.api.rules.Rule.create(rule.getRepositoryKey(), rule.getRuleKey()), severity);
+ }
+
+ private QProfileDto verifyProfileInDb(OrganizationDto organization, BuiltInQProfile builtIn) {
+ QProfileDto profileOnOrg1 = db.getDbClient().qualityProfileDao().selectByNameAndLanguage(dbSession, organization, builtIn.getName(), builtIn.getLanguage());
+ assertThat(profileOnOrg1.getLanguage()).isEqualTo(builtIn.getLanguage());
+ assertThat(profileOnOrg1.getName()).isEqualTo(builtIn.getName());
+ assertThat(profileOnOrg1.getOrganizationUuid()).isEqualTo(organization.getUuid());
+ assertThat(profileOnOrg1.getParentKee()).isNull();
+ assertThat(profileOnOrg1.getLastUsed()).isNull();
+ assertThat(profileOnOrg1.getUserUpdatedAt()).isNull();
+ assertThat(profileOnOrg1.getRulesUpdatedAt()).isNotEmpty();
+ assertThat(profileOnOrg1.getKee()).isNotEqualTo(profileOnOrg1.getRulesProfileUuid());
+ assertThat(profileOnOrg1.getId()).isNotNull();
+ return profileOnOrg1;
+ }
+
+ private void verifyTableSize(String table, int expectedSize) {
+ assertThat(db.countRowsOfTable(dbSession, table)).as("table " + table).isEqualTo(expectedSize);
+ }
+
+ private void call(BuiltInQProfile builtIn) {
+ underTest.create(dbSession, batchDbSession, builtIn);
+ dbSession.commit();
+ batchDbSession.commit();
+ }
+
+}
+++ /dev/null
-/*
- * SonarQube
- * Copyright (C) 2009-2017 SonarSource SA
- * mailto:info AT sonarsource DOT com
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 3 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-package org.sonar.server.qualityprofile;
-
-import java.util.ArrayList;
-import java.util.List;
-import org.junit.rules.ExternalResource;
-import org.sonar.db.DbSession;
-import org.sonar.db.organization.OrganizationDto;
-
-public class BuiltInQProfileInsertRule extends ExternalResource implements BuiltInQProfileInsert {
- private final List<BuiltInQProfileInsertRule.CallLog> callLogs = new ArrayList<>();
-
- @Override
- protected void before() throws Throwable {
- callLogs.clear();
- }
-
- @Override
- public void create(DbSession session, DbSession batchSession, BuiltInQProfile builtInQProfile, OrganizationDto organization) {
- callLogs.add(new BuiltInQProfileInsertRule.CallLog(builtInQProfile, organization));
- }
-
- public List<BuiltInQProfileInsertRule.CallLog> getCallLogs() {
- return callLogs;
- }
-
- public static final class CallLog {
- private final BuiltInQProfile builtInQProfile;
- private final OrganizationDto organizationDto;
-
- private CallLog(BuiltInQProfile builtInQProfile, OrganizationDto organizationDto) {
- this.builtInQProfile = builtInQProfile;
- this.organizationDto = organizationDto;
- }
-
- public BuiltInQProfile getDefinedQProfile() {
- return builtInQProfile;
- }
-
- public OrganizationDto getOrganizationDto() {
- return organizationDto;
- }
- }
-}
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
-import java.util.Map;
import java.util.Random;
import org.junit.Rule;
import org.junit.Test;
import static java.util.Arrays.asList;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.groups.Tuple.tuple;
public class BuiltInQProfileRepositoryImplTest {
private static final Language FOO_LANGUAGE = LanguageTesting.newLanguage("foo", "foo", "foo");
public ExpectedException expectedException = ExpectedException.none();
@Test
- public void getQProfilesByLanguage_throws_ISE_if_called_before_initialize() {
+ public void get_throws_ISE_if_called_before_initialize() {
BuiltInQProfileRepositoryImpl underTest = new BuiltInQProfileRepositoryImpl(new Languages());
expectedException.expect(IllegalStateException.class);
expectedException.expectMessage("initialize must be called first");
- underTest.getQProfilesByLanguage();
+ underTest.get();
}
@Test
}
@Test
- public void initialize_creates_no_DefinedQProfile_when_there_is_no_definition() {
+ public void initialize_creates_no_BuiltInQProfile_when_there_is_no_definition() {
BuiltInQProfileRepository underTest = new BuiltInQProfileRepositoryImpl(new Languages(FOO_LANGUAGE));
underTest.initialize();
- assertThat(underTest.getQProfilesByLanguage()).isEmpty();
+ assertThat(underTest.get()).isEmpty();
}
@Test
- public void initialize_creates_no_DefinedQProfile_when_all_definitions_apply_to_non_defined_languages() {
+ public void initialize_creates_no_BuiltInQProfile_when_all_definitions_apply_to_non_defined_languages() {
BuiltInQProfileRepository underTest = new BuiltInQProfileRepositoryImpl(new Languages(), new DummyProfileDefinition("foo", "P1", false));
underTest.initialize();
- assertThat(underTest.getQProfilesByLanguage()).isEmpty();
+ assertThat(underTest.get()).isEmpty();
}
@Test
}
@Test
- public void initialize_makes_single_qp_of_a_language_default_even_if_not_flagged_as_so() {
+ public void initialize_makes_single_profile_of_a_language_default_even_if_not_flagged_as_so() {
BuiltInQProfileRepository underTest = new BuiltInQProfileRepositoryImpl(new Languages(FOO_LANGUAGE), new DummyProfileDefinition("foo", "foo1", false));
underTest.initialize();
- Map<String, List<BuiltInQProfile>> qProfilesByLanguage = underTest.getQProfilesByLanguage();
- assertThat(qProfilesByLanguage)
- .hasSize(1)
- .containsOnlyKeys(FOO_LANGUAGE.getKey());
- assertThat(qProfilesByLanguage.get(FOO_LANGUAGE.getKey()))
- .extracting(BuiltInQProfile::isDefault)
- .containsExactly(true);
+ assertThat(underTest.get())
+ .extracting(BuiltInQProfile::getLanguage, BuiltInQProfile::isDefault)
+ .containsExactly(tuple(FOO_LANGUAGE.getKey(), true));
}
@Test
- public void initialize_makes_single_qp_of_a_language_default_even_if_flagged_as_so() {
+ public void initialize_makes_single_profile_of_a_language_default_even_if_flagged_as_so() {
BuiltInQProfileRepository underTest = new BuiltInQProfileRepositoryImpl(new Languages(FOO_LANGUAGE), new DummyProfileDefinition("foo", "foo1", true));
underTest.initialize();
- Map<String, List<BuiltInQProfile>> qProfilesByLanguage = underTest.getQProfilesByLanguage();
- assertThat(qProfilesByLanguage)
- .hasSize(1)
- .containsOnlyKeys(FOO_LANGUAGE.getKey());
- assertThat(qProfilesByLanguage.get(FOO_LANGUAGE.getKey()))
- .extracting(BuiltInQProfile::isDefault)
- .containsExactly(true);
+ assertThat(underTest.get())
+ .extracting(BuiltInQProfile::getLanguage, BuiltInQProfile::isDefault)
+ .containsExactly(tuple(FOO_LANGUAGE.getKey(), true));
}
@Test
- public void initialize_makes_first_qp_of_a_language_default_when_none_flagged_as_so() {
+ public void initialize_makes_first_profile_of_a_language_default_when_none_flagged_as_so() {
List<DummyProfileDefinition> definitions = new ArrayList<>(
asList(new DummyProfileDefinition("foo", "foo1", false), new DummyProfileDefinition("foo", "foo2", false)));
Collections.shuffle(definitions);
- String firstQPName = definitions.get(0).getName();
- String secondQPName = definitions.get(1).getName();
- BuiltInQProfileRepository underTest = new BuiltInQProfileRepositoryImpl(new Languages(FOO_LANGUAGE), definitions.stream().toArray(ProfileDefinition[]::new));
+ String firstName = definitions.get(0).getName();
+ String secondName = definitions.get(1).getName();
+ BuiltInQProfileRepository underTest = new BuiltInQProfileRepositoryImpl(new Languages(FOO_LANGUAGE), definitions.toArray(new ProfileDefinition[0]));
underTest.initialize();
- Map<String, List<BuiltInQProfile>> qProfilesByLanguage = underTest.getQProfilesByLanguage();
- assertThat(qProfilesByLanguage)
- .hasSize(1)
- .containsOnlyKeys(FOO_LANGUAGE.getKey());
- List<BuiltInQProfile> fooBuiltInQProfiles = qProfilesByLanguage.get(FOO_LANGUAGE.getKey());
- assertThat(fooBuiltInQProfiles)
- .extracting(BuiltInQProfile::getName)
- .containsExactly(firstQPName, secondQPName);
- assertThat(fooBuiltInQProfiles)
- .extracting(BuiltInQProfile::isDefault)
- .containsExactly(true, false);
+ assertThat(underTest.get())
+ .extracting(BuiltInQProfile::getName, BuiltInQProfile::isDefault)
+ .containsExactlyInAnyOrder(tuple(firstName, true), tuple(secondName, false));
}
@Test
- public void initialize_fails_with_ISE_when_two_sq_with_different_name_are_default_for_the_same_language() {
+ public void initialize_fails_with_ISE_when_two_profiles_with_different_name_are_default_for_the_same_language() {
BuiltInQProfileRepository underTest = new BuiltInQProfileRepositoryImpl(new Languages(FOO_LANGUAGE),
new DummyProfileDefinition("foo", "foo1", true), new DummyProfileDefinition("foo", "foo2", true));
}
@Test
- public void initialize_create_qp_as_default_even_if_only_one_profile_with_given_name_has_default_flag_true() {
+ public void initialize_creates_profile_as_default_even_if_only_one_profile_with_given_name_has_default_flag_true() {
String name = "doh";
boolean flag = new Random().nextBoolean();
BuiltInQProfileRepository underTest = new BuiltInQProfileRepositoryImpl(new Languages(FOO_LANGUAGE),
underTest.initialize();
- assertThat(underTest.getQProfilesByLanguage().get(FOO_LANGUAGE.getKey()))
- .extracting(BuiltInQProfile::isDefault)
- .containsExactly(true);
+ assertThat(underTest.get())
+ .extracting(BuiltInQProfile::getLanguage, BuiltInQProfile::isDefault)
+ .containsExactly(tuple("foo", true));
}
@Test
- public void initialize_creates_single_qp_if_several_profile_have_the_same_name_for_a_given_language() {
+ public void initialize_creates_single_profile_if_several_profile_have_the_same_name_for_a_given_language() {
BuiltInQProfileRepository underTest = new BuiltInQProfileRepositoryImpl(new Languages(FOO_LANGUAGE),
- new DummyProfileDefinition("foo", "foo1", true), new DummyProfileDefinition("foo", "foo1", true));
+ new DummyProfileDefinition("foo", "aName", true), new DummyProfileDefinition("foo", "aName", true));
underTest.initialize();
- Map<String, List<BuiltInQProfile>> qProfilesByLanguage = underTest.getQProfilesByLanguage();
- assertThat(qProfilesByLanguage)
- .hasSize(1)
- .containsOnlyKeys(FOO_LANGUAGE.getKey());
- assertThat(qProfilesByLanguage.get(FOO_LANGUAGE.getKey()))
- .extracting(BuiltInQProfile::getName)
- .containsExactly("foo1");
+ assertThat(underTest.get())
+ .extracting(BuiltInQProfile::getLanguage, BuiltInQProfile::getName)
+ .containsExactlyInAnyOrder(tuple(FOO_LANGUAGE.getKey(), "aName"));
}
@Test
- public void initialize_creates_qp_Sonar_Way_as_default_if_none_other_is_defined_default_for_a_given_language() {
+ public void initialize_creates_profile_Sonar_Way_as_default_if_none_other_is_defined_default_for_a_given_language() {
BuiltInQProfileRepository underTest = new BuiltInQProfileRepositoryImpl(
new Languages(FOO_LANGUAGE),
new DummyProfileDefinition("foo", "doh", false), new DummyProfileDefinition("foo", "boo", false),
underTest.initialize();
- Map<String, List<BuiltInQProfile>> qProfilesByLanguage = underTest.getQProfilesByLanguage();
- assertThat(qProfilesByLanguage)
- .hasSize(1)
- .containsOnlyKeys(FOO_LANGUAGE.getKey());
- List<BuiltInQProfile> fooBuiltInQProfiles = qProfilesByLanguage.get(FOO_LANGUAGE.getKey());
- assertThat(fooBuiltInQProfiles)
+ assertThat(underTest.get())
+ .filteredOn(b -> FOO_LANGUAGE.getKey().equals(b.getLanguage()))
+ .filteredOn(BuiltInQProfile::isDefault)
.extracting(BuiltInQProfile::getName)
- .containsExactly("doh", "boo", SONAR_WAY_QP_NAME, "goo");
- assertThat(fooBuiltInQProfiles)
- .extracting(BuiltInQProfile::isDefault)
- .containsExactly(false, false, true, false);
+ .containsExactly(SONAR_WAY_QP_NAME);
}
@Test
underTest.initialize();
- List<BuiltInQProfile> fooBuiltInQProfiles = underTest.getQProfilesByLanguage().get(FOO_LANGUAGE.getKey());
- assertThat(fooBuiltInQProfiles)
+ assertThat(underTest.get())
+ .filteredOn(b -> FOO_LANGUAGE.getKey().equals(b.getLanguage()))
+ .filteredOn(BuiltInQProfile::isDefault)
.extracting(BuiltInQProfile::getName)
- .containsExactly(SONAR_WAY_QP_NAME, "goo");
- assertThat(fooBuiltInQProfiles)
- .extracting(BuiltInQProfile::isDefault)
- .containsExactly(false, true);
+ .containsExactly("goo");
}
@Test
underTest.initialize();
- List<BuiltInQProfile> fooBuiltInQProfiles = underTest.getQProfilesByLanguage().get(FOO_LANGUAGE.getKey());
- assertThat(fooBuiltInQProfiles)
+ assertThat(underTest.get())
+ .filteredOn(b -> FOO_LANGUAGE.getKey().equals(b.getLanguage()))
+ .filteredOn(BuiltInQProfile::isDefault)
.extracting(BuiltInQProfile::getName)
- .containsExactly("goo", sonarWayInOtherCase);
- assertThat(fooBuiltInQProfiles)
- .extracting(BuiltInQProfile::isDefault)
- .containsExactly(true, false);
+ .containsExactly("goo");
}
private static final class DummyProfileDefinition extends ProfileDefinition {
package org.sonar.server.qualityprofile;
import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
+import java.util.ArrayList;
import java.util.Arrays;
-import java.util.HashMap;
import java.util.List;
-import java.util.Map;
-import java.util.stream.Stream;
import org.junit.rules.ExternalResource;
+import org.sonar.api.profiles.RulesProfile;
import org.sonar.api.resources.Language;
-import org.sonar.core.util.stream.MoreCollectors;
import static com.google.common.base.Preconditions.checkState;
-import static org.sonar.core.util.stream.MoreCollectors.toList;
public class BuiltInQProfileRepositoryRule extends ExternalResource implements BuiltInQProfileRepository {
private boolean initializeCalled = false;
- private Map<String, List<BuiltInQProfile>> qProfilesbyLanguage = new HashMap<>();
+ private List<BuiltInQProfile> profiles = new ArrayList<>();
@Override
protected void before() throws Throwable {
this.initializeCalled = false;
- this.qProfilesbyLanguage.clear();
+ this.profiles.clear();
}
@Override
}
@Override
- public Map<String, List<BuiltInQProfile>> getQProfilesByLanguage() {
+ public List<BuiltInQProfile> get() {
checkState(initializeCalled, "initialize must be called first");
- return ImmutableMap.copyOf(qProfilesbyLanguage);
+ return ImmutableList.copyOf(profiles);
}
public boolean isInitialized() {
return initializeCalled;
}
- public BuiltInQProfileRepositoryRule set(String languageKey, BuiltInQProfile first, BuiltInQProfile... others) {
- qProfilesbyLanguage.put(
- languageKey,
- Stream.concat(Stream.of(first), Arrays.stream(others)).collect(toList(1 + others.length)));
- return this;
- }
-
public BuiltInQProfile add(Language language, String profileName) {
return add(language, profileName, false);
}
public BuiltInQProfile add(Language language, String profileName, boolean isDefault) {
- BuiltInQProfile builtInQProfile = create(language, profileName, isDefault);
- qProfilesbyLanguage.compute(language.getKey(),
- (key, existing) -> {
- if (existing == null) {
- return ImmutableList.of(builtInQProfile);
- }
- return Stream.concat(existing.stream(), Stream.of(builtInQProfile)).collect(MoreCollectors.toList(existing.size() + 1));
- });
- return builtInQProfile;
+ BuiltInQProfile builtIn = create(language, profileName, isDefault);
+ profiles.add(builtIn);
+ return builtIn;
}
public BuiltInQProfile create(Language language, String profileName, boolean isDefault, org.sonar.api.rules.ActiveRule... rules) {
.addRules(Arrays.asList(rules))
.build();
}
+
+ public BuiltInQProfile create(RulesProfile api) {
+ return new BuiltInQProfile.Builder()
+ .setLanguage(api.getLanguage())
+ .setName(api.getName())
+ .setDeclaredDefault(api.getDefaultProfile())
+ .addRules(new ArrayList<>(api.getActiveRules()))
+ .build();
+ }
}
public class QProfileBackuperMediumTest {
- @ClassRule
- public static ServerTester tester = new ServerTester().withEsIndexes();
- @Rule
- public ExpectedException thrown = ExpectedException.none();
- @Rule
- public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
-
- private DbClient db;
- private DbSession dbSession;
- private RuleIndexer ruleIndexer;
- private ActiveRuleIndexer activeRuleIndexer;
- private OrganizationDto organization;
-
- @Before
- public void before() {
- tester.clearDbAndIndexes();
- db = tester.get(DbClient.class);
- dbSession = db.openSession(false);
- ruleIndexer = tester.get(RuleIndexer.class);
- activeRuleIndexer = tester.get(ActiveRuleIndexer.class);
-
- // create pre-defined rules
- RuleDto xooRule1 = newXooX1().setSeverity("MINOR").setLanguage("xoo");
- db.ruleDao().insert(dbSession, xooRule1.getDefinition());
- db.ruleDao().insertRuleParam(dbSession, xooRule1.getDefinition(), RuleParamDto.createFor(xooRule1.getDefinition())
- .setName("max").setDefaultValue("10").setType(RuleParamType.INTEGER.type()));
- dbSession.commit();
- ruleIndexer.indexRuleDefinition(xooRule1.getDefinition().getKey());
-
- RuleDto xooRule2 = newXooX2().setSeverity("MAJOR").setLanguage("xoo");
- db.ruleDao().insert(dbSession, xooRule2.getDefinition());
- dbSession.commit();
- ruleIndexer.indexRuleDefinition(xooRule2.getDefinition().getKey());
-
- this.organization = OrganizationTesting.newOrganizationDto();
- db.organizationDao().insert(dbSession, organization, false);
- }
-
- @After
- public void after() {
- dbSession.close();
- }
-
- @Test
- public void backup() throws Exception {
- RuleKey blahRuleKey = RuleKey.of("blah", "my-rule");
- RuleDefinitionDto blahRule = newRule(blahRuleKey).setSeverity("INFO").setLanguage("xoo");
- db.ruleDao().insert(dbSession, blahRule);
- dbSession.commit();
- ruleIndexer.indexRuleDefinition(blahRule.getKey());
-
- // create profile P1 with rules x2 and x1 activated
- QProfileDto profile = newXooP1(organization);
- db.qualityProfileDao().insert(dbSession, profile);
- RuleActivation activation1 = new RuleActivation(XOO_X2).setSeverity("MINOR");
- RuleActivation activation2 = new RuleActivation(XOO_X1);
- RuleActivation activation3 = new RuleActivation(blahRuleKey);
- activation2.setSeverity(Severity.BLOCKER);
- activation2.setParameter("max", "7");
- QProfileDto profileDto = get(XOO_P1_NAME);
- tester.get(RuleActivator.class).activate(dbSession, activation1, profileDto);
- tester.get(RuleActivator.class).activate(dbSession, activation2, profileDto);
- tester.get(RuleActivator.class).activate(dbSession, activation3, profileDto);
- dbSession.commit();
- dbSession.clearCache();
- activeRuleIndexer.index();
-
- StringWriter output = new StringWriter();
- tester.get(QProfileBackuper.class).backup(dbSession, profile, output);
-
- String expectedXml = Resources.toString(getClass().getResource("QProfileBackuperMediumTest/expected-backup.xml"), StandardCharsets.UTF_8);
- assertThat(output.toString()).isXmlEqualTo(expectedXml);
- }
-
- @Test
- public void restore_and_create_profile() throws Exception {
- // Backup file declares profile P1 on xoo
- tester.get(QProfileBackuper.class).restore(dbSession, new StringReader(
- Resources.toString(getClass().getResource("QProfileBackuperMediumTest/restore.xml"), StandardCharsets.UTF_8)),
- organization, null);
-
- // Check in db
- QProfileDto profile = db.qualityProfileDao().selectByNameAndLanguage(dbSession, organization, "P1", "xoo");
- assertThat(profile).isNotNull();
-
- List<ActiveRuleDto> activeRules = db.activeRuleDao().selectByProfileKey(dbSession, profile.getKee());
- assertThat(activeRules).hasSize(1);
- ActiveRuleDto activeRuleDoc = activeRules.get(0);
- assertThat(activeRuleDoc.getSeverityString()).isEqualTo("BLOCKER");
- assertThat(activeRuleDoc.getInheritance()).isNull();
-
- ActiveRuleDto activeRuleDto = db.activeRuleDao().selectOrFailByKey(dbSession, activeRuleDoc.getKey());
- List<ActiveRuleParamDto> params = tester.get(ActiveRuleDao.class).selectParamsByActiveRuleId(dbSession, activeRuleDto.getId());
- assertThat(params).hasSize(1);
- assertThat(params.get(0).getKey()).isEqualTo("max");
- assertThat(params.get(0).getValue()).isEqualTo("7");
-
- // Check in es
- assertThat(tester.get(RuleIndex.class).searchAll(new RuleQuery().setQProfileKey(profile.getKee()).setActivation(true))).containsOnly(XOO_X1);
- }
-
- @Test
- public void restore_and_update_profile() throws Exception {
- // create profile P1 with rules x1 and x2 activated
- db.qualityProfileDao().insert(dbSession, newXooP1(organization));
- RuleActivation activation = new RuleActivation(XOO_X1);
- activation.setSeverity(Severity.INFO);
- activation.setParameter("max", "10");
- QProfileDto profileDto = get(XOO_P1_NAME);
- tester.get(RuleActivator.class).activate(dbSession, activation, profileDto);
-
- activation = new RuleActivation(XOO_X2);
- activation.setSeverity(Severity.INFO);
- tester.get(RuleActivator.class).activate(dbSession, activation, profileDto);
- dbSession.commit();
- dbSession.clearCache();
- activeRuleIndexer.index();
-
- // restore backup, which activates only x1
- // -> update x1 and deactivate x2
- tester.get(QProfileBackuper.class).restore(dbSession, new StringReader(
- Resources.toString(getClass().getResource("QProfileBackuperMediumTest/restore.xml"), StandardCharsets.UTF_8)), organization, null);
-
- // Check in db
- List<ActiveRuleDto> activeRules = db.activeRuleDao().selectByProfileKey(dbSession, XOO_P1_KEY);
- assertThat(activeRules).hasSize(1);
- ActiveRuleDto activeRuleDoc = activeRules.get(0);
- assertThat(activeRuleDoc.getSeverityString()).isEqualTo("BLOCKER");
- assertThat(activeRuleDoc.getInheritance()).isNull();
-
- ActiveRuleDto activeRuleDto = db.activeRuleDao().selectOrFailByKey(dbSession, activeRuleDoc.getKey());
- List<ActiveRuleParamDto> params = tester.get(ActiveRuleDao.class).selectParamsByActiveRuleId(dbSession, activeRuleDto.getId());
- assertThat(params).hasSize(1);
- assertThat(params.get(0).getKey()).isEqualTo("max");
- assertThat(params.get(0).getValue()).isEqualTo("7");
-
- // Check in es
- assertThat(tester.get(RuleIndex.class).searchAll(new RuleQuery().setQProfileKey(XOO_P1_KEY).setActivation(true))).containsOnly(XOO_X1);
- }
-
- @Test
- public void restore_child_profile() throws Exception {
- // define two parent/child profiles
- db.qualityProfileDao().insert(dbSession,
- newXooP1(organization),
- newXooP2(organization).setParentKee(XOO_P1_KEY));
- dbSession.commit();
-
- // rule x1 is activated on parent profile (so inherited by child profile)
- RuleActivation activation = new RuleActivation(XOO_X1);
- activation.setSeverity(Severity.INFO);
- activation.setParameter("max", "10");
- tester.get(RuleActivator.class).activate(dbSession, activation, XOO_P1_KEY);
- dbSession.commit();
- dbSession.clearCache();
- activeRuleIndexer.index();
-
- // restore backup of child profile -> overrides x1
- tester.get(QProfileBackuper.class).restore(dbSession, new StringReader(
- Resources.toString(getClass().getResource("QProfileBackuperMediumTest/restore-child.xml"), StandardCharsets.UTF_8)), organization, null);
-
- // parent profile is unchanged
- List<ActiveRuleDto> activeRules = db.activeRuleDao().selectByProfileKey(dbSession, XOO_P1_KEY);
- assertThat(activeRules).hasSize(1);
- ActiveRuleDto activeRuleDoc = activeRules.get(0);
- assertThat(activeRuleDoc.getSeverityString()).isEqualTo("INFO");
- assertThat(activeRuleDoc.getInheritance()).isNull();
-
- ActiveRuleDto activeRuleDto = db.activeRuleDao().selectOrFailByKey(dbSession, activeRuleDoc.getKey());
- List<ActiveRuleParamDto> params = tester.get(ActiveRuleDao.class).selectParamsByActiveRuleId(dbSession, activeRuleDto.getId());
- assertThat(params).hasSize(1);
- assertThat(params.get(0).getKey()).isEqualTo("max");
- assertThat(params.get(0).getValue()).isEqualTo("10");
-
- // child profile overrides parent
- activeRules = db.activeRuleDao().selectByProfileKey(dbSession, XOO_P2_KEY);
- assertThat(activeRules).hasSize(1);
- activeRuleDoc = activeRules.get(0);
- assertThat(activeRuleDoc.getSeverityString()).isEqualTo("BLOCKER");
- assertThat(activeRuleDoc.getInheritance()).isEqualTo(OVERRIDES);
-
- activeRuleDto = db.activeRuleDao().selectOrFailByKey(dbSession, activeRuleDoc.getKey());
- params = tester.get(ActiveRuleDao.class).selectParamsByActiveRuleId(dbSession, activeRuleDto.getId());
- assertThat(params).hasSize(1);
- assertThat(params.get(0).getKey()).isEqualTo("max");
- assertThat(params.get(0).getValue()).isEqualTo("7");
- }
-
- @Test
- public void restore_parent_profile() throws Exception {
- // define two parent/child profiles
- db.qualityProfileDao().insert(dbSession,
- newXooP1(organization),
- newXooP2(organization).setParentKee(XOO_P1_KEY));
- dbSession.commit();
-
- // rule x1 is activated on parent profile (so inherited by child profile)
- RuleActivation activation = new RuleActivation(XOO_X1);
- activation.setSeverity(Severity.INFO);
- activation.setParameter("max", "10");
- tester.get(RuleActivator.class).activate(dbSession, activation, XOO_P1_KEY);
- dbSession.commit();
- dbSession.clearCache();
- activeRuleIndexer.index();
-
- // restore backup of parent profile -> update x1 and propagates to child
- tester.get(QProfileBackuper.class).restore(dbSession, new StringReader(
- Resources.toString(getClass().getResource("QProfileBackuperMediumTest/restore-parent.xml"), StandardCharsets.UTF_8)), organization, null);
-
- // parent profile is updated
- List<ActiveRuleDto> activeRules = db.activeRuleDao().selectByProfileKey(dbSession, XOO_P1_KEY);
- assertThat(activeRules).hasSize(1);
-
- ActiveRuleDto activeRuleDoc = activeRules.get(0);
- assertThat(activeRuleDoc.getSeverityString()).isEqualTo("BLOCKER");
- assertThat(activeRuleDoc.getInheritance()).isNull();
-
- ActiveRuleDto activeRuleDto = db.activeRuleDao().selectOrFailByKey(dbSession, activeRuleDoc.getKey());
- List<ActiveRuleParamDto> params = tester.get(ActiveRuleDao.class).selectParamsByActiveRuleId(dbSession, activeRuleDto.getId());
- assertThat(params).hasSize(1);
- assertThat(params.get(0).getKey()).isEqualTo("max");
- assertThat(params.get(0).getValue()).isEqualTo("7");
-
- // child profile is inherited
- activeRules = db.activeRuleDao().selectByProfileKey(dbSession, XOO_P2_KEY);
- assertThat(activeRules).hasSize(1);
- activeRuleDoc = activeRules.get(0);
- assertThat(activeRuleDoc.getSeverityString()).isEqualTo("BLOCKER");
- assertThat(activeRuleDoc.getInheritance()).isEqualTo(INHERITED);
-
- activeRuleDto = db.activeRuleDao().selectOrFailByKey(dbSession, activeRuleDoc.getKey());
- params = tester.get(ActiveRuleDao.class).selectParamsByActiveRuleId(dbSession, activeRuleDto.getId());
- assertThat(params).hasSize(1);
- assertThat(params.get(0).getKey()).isEqualTo("max");
- assertThat(params.get(0).getValue()).isEqualTo("7");
- }
-
- @Test
- public void keep_other_inherited_rules() throws Exception {
- // define two parent/child profiles
- db.qualityProfileDao().insert(dbSession,
- newXooP1(organization),
- newXooP2(organization).setParentKee(XOO_P1_KEY));
- dbSession.commit();
-
- // rule x1 is activated on parent profile and is inherited by child profile
- RuleActivation activation = new RuleActivation(XOO_X1);
- activation.setSeverity(Severity.INFO);
- activation.setParameter("max", "10");
- tester.get(RuleActivator.class).activate(dbSession, activation, XOO_P1_KEY);
- dbSession.commit();
- dbSession.clearCache();
- activeRuleIndexer.index();
-
- // backup of child profile contains x2 but not x1
- tester.get(QProfileBackuper.class).restore(dbSession, new StringReader(
- Resources.toString(getClass().getResource("QProfileBackuperMediumTest/keep_other_inherited_rules.xml"), StandardCharsets.UTF_8)), organization, XOO_P2_NAME.getName());
-
- // x1 and x2
- assertThat(db.activeRuleDao().selectByProfileKey(dbSession, XOO_P2_KEY)).hasSize(2);
- }
-
- @Test
- public void fail_to_restore_if_not_xml_backup() throws Exception {
- try {
- tester.get(QProfileBackuper.class).restore(dbSession, new StringReader(
- Resources.toString(getClass().getResource("QProfileBackuperMediumTest/not-xml-backup.txt"), StandardCharsets.UTF_8)), organization, null);
- fail();
- } catch (IllegalStateException e) {
- assertThat(e).hasMessage("Fail to restore Quality profile backup");
- assertThat(e.getCause()).isInstanceOf(XMLStreamException.class);
- }
- }
-
- @Test
- public void fail_to_restore_if_bad_xml_format() throws Exception {
- try {
- tester.get(QProfileBackuper.class).restore(dbSession, new StringReader(
- Resources.toString(getClass().getResource("QProfileBackuperMediumTest/bad-xml-backup.xml"), StandardCharsets.UTF_8)), organization, null);
- fail();
- } catch (IllegalArgumentException e) {
- assertThat(e).hasMessage("Backup XML is not valid. Root element must be <profile>.");
- }
- }
-
- @Test
- public void fail_to_restore_if_duplicate_rule() throws Exception {
- try {
- tester.get(QProfileBackuper.class).restore(dbSession, new StringReader(
- Resources.toString(getClass().getResource("QProfileBackuperMediumTest/duplicates-xml-backup.xml"), StandardCharsets.UTF_8)), organization, null);
- fail();
- } catch (IllegalArgumentException e) {
- assertThat(e).hasMessage("The quality profile cannot be restored as it contains duplicates for the following rules: xoo:x1, xoo:x2");
- }
- }
-
- @Test
- public void restore_and_override_profile_name() throws Exception {
- tester.get(QProfileBackuper.class).restore(dbSession, new StringReader(
- Resources.toString(getClass().getResource("QProfileBackuperMediumTest/restore.xml"), StandardCharsets.UTF_8)),
- organization, XOO_P3_NAME.getName());
-
- List<ActiveRuleDto> activeRules = db.activeRuleDao().selectByProfileKey(dbSession, XOO_P1_KEY);
- assertThat(activeRules).hasSize(0);
-
- QProfileDto target = db.qualityProfileDao().selectByNameAndLanguage(dbSession, organization, "P3", "xoo");
- assertThat(target).isNotNull();
- assertThat(db.activeRuleDao().selectByProfileKey(dbSession, target.getKee())).hasSize(1);
- }
-
- @Test
- public void restore_profile_with_zero_rules() throws Exception {
- tester.get(QProfileBackuper.class).restore(dbSession, new StringReader(
- Resources.toString(getClass().getResource("QProfileBackuperMediumTest/empty.xml"), StandardCharsets.UTF_8)),
- organization, null);
-
- dbSession.clearCache();
- assertThat(anyActiveRuleExists()).isFalse();
- List<QProfileDto> profiles = db.qualityProfileDao().selectAll(dbSession, organization);
- assertThat(profiles).hasSize(1);
- assertThat(profiles.get(0).getName()).isEqualTo("P1");
- }
-
- private boolean anyActiveRuleExists() throws SQLException {
- try (PreparedStatement preparedStatement = db.openSession(false).getConnection().prepareStatement("SELECT * FROM active_rules");
- ResultSet resultSet = preparedStatement.executeQuery();) {
- return resultSet.next();
- }
- }
-
- private QProfileDto get(QProfileName profileName) {
- return db.qualityProfileDao().selectByNameAndLanguage(dbSession, organization, profileName.getName(), profileName.getLanguage());
- }
+// @ClassRule
+// public static ServerTester tester = new ServerTester().withEsIndexes();
+// @Rule
+// public ExpectedException thrown = ExpectedException.none();
+// @Rule
+// public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
+//
+// private DbClient db;
+// private DbSession dbSession;
+// private RuleIndexer ruleIndexer;
+// private ActiveRuleIndexer activeRuleIndexer;
+// private OrganizationDto organization;
+//
+// @Before
+// public void before() {
+// tester.clearDbAndIndexes();
+// db = tester.get(DbClient.class);
+// dbSession = db.openSession(false);
+// ruleIndexer = tester.get(RuleIndexer.class);
+// activeRuleIndexer = tester.get(ActiveRuleIndexer.class);
+//
+// // create pre-defined rules
+// RuleDto xooRule1 = newXooX1().setSeverity("MINOR").setLanguage("xoo");
+// db.ruleDao().insert(dbSession, xooRule1.getDefinition());
+// db.ruleDao().insertRuleParam(dbSession, xooRule1.getDefinition(), RuleParamDto.createFor(xooRule1.getDefinition())
+// .setName("max").setDefaultValue("10").setType(RuleParamType.INTEGER.type()));
+// dbSession.commit();
+// ruleIndexer.indexRuleDefinition(xooRule1.getDefinition().getKey());
+//
+// RuleDto xooRule2 = newXooX2().setSeverity("MAJOR").setLanguage("xoo");
+// db.ruleDao().insert(dbSession, xooRule2.getDefinition());
+// dbSession.commit();
+// ruleIndexer.indexRuleDefinition(xooRule2.getDefinition().getKey());
+//
+// this.organization = OrganizationTesting.newOrganizationDto();
+// db.organizationDao().insert(dbSession, organization, false);
+// }
+//
+// @After
+// public void after() {
+// dbSession.close();
+// }
+//
+// @Test
+// public void backup() throws Exception {
+// RuleKey blahRuleKey = RuleKey.of("blah", "my-rule");
+// RuleDefinitionDto blahRule = newRule(blahRuleKey).setSeverity("INFO").setLanguage("xoo");
+// db.ruleDao().insert(dbSession, blahRule);
+// dbSession.commit();
+// ruleIndexer.indexRuleDefinition(blahRule.getKey());
+//
+// // create profile P1 with rules x2 and x1 activated
+// QProfileDto profile = newXooP1(organization);
+// db.qualityProfileDao().insert(dbSession, profile);
+// RuleActivation activation1 = new RuleActivation(XOO_X2).setSeverity("MINOR");
+// RuleActivation activation2 = new RuleActivation(XOO_X1);
+// RuleActivation activation3 = new RuleActivation(blahRuleKey);
+// activation2.setSeverity(Severity.BLOCKER);
+// activation2.setParameter("max", "7");
+// QProfileDto profileDto = get(XOO_P1_NAME);
+// tester.get(RuleActivator.class).activate(dbSession, activation1, profileDto);
+// tester.get(RuleActivator.class).activate(dbSession, activation2, profileDto);
+// tester.get(RuleActivator.class).activate(dbSession, activation3, profileDto);
+// dbSession.commit();
+// dbSession.clearCache();
+// activeRuleIndexer.index();
+//
+// StringWriter output = new StringWriter();
+// tester.get(QProfileBackuper.class).backup(dbSession, profile, output);
+//
+// String expectedXml = Resources.toString(getClass().getResource("QProfileBackuperMediumTest/expected-backup.xml"), StandardCharsets.UTF_8);
+// assertThat(output.toString()).isXmlEqualTo(expectedXml);
+// }
+//
+// @Test
+// public void restore_and_create_profile() throws Exception {
+// // Backup file declares profile P1 on xoo
+// tester.get(QProfileBackuper.class).restore(dbSession, new StringReader(
+// Resources.toString(getClass().getResource("QProfileBackuperMediumTest/restore.xml"), StandardCharsets.UTF_8)),
+// organization, null);
+//
+// // Check in db
+// QProfileDto profile = db.qualityProfileDao().selectByNameAndLanguage(dbSession, organization, "P1", "xoo");
+// assertThat(profile).isNotNull();
+//
+// List<ActiveRuleDto> activeRules = db.activeRuleDao().selectByProfileUuid(dbSession, profile.getKee());
+// assertThat(activeRules).hasSize(1);
+// ActiveRuleDto activeRuleDoc = activeRules.get(0);
+// assertThat(activeRuleDoc.getSeverityString()).isEqualTo("BLOCKER");
+// assertThat(activeRuleDoc.getInheritance()).isNull();
+//
+// ActiveRuleDto activeRuleDto = db.activeRuleDao().selectOrFailByKey(dbSession, activeRuleDoc.getKey());
+
// List<ActiveRuleParamDto> params = tester.get(ActiveRuleDao.class).selectParamsByActiveRuleId(dbSession, activeRuleDto.getId());
+// assertThat(params).hasSize(1);
+// assertThat(params.get(0).getKey()).isEqualTo("max");
+// assertThat(params.get(0).getValue()).isEqualTo("7");
+//
+// // Check in es
+// assertThat(tester.get(RuleIndex.class).searchAll(new RuleQuery().setQProfileKey(profile.getKee()).setActivation(true))).containsOnly(XOO_X1);
+// }
+//
+// @Test
+// public void restore_and_update_profile() throws Exception {
+// // create profile P1 with rules x1 and x2 activated
+// db.qualityProfileDao().insert(dbSession, newXooP1(organization));
+// RuleActivation activation = new RuleActivation(XOO_X1);
+// activation.setSeverity(Severity.INFO);
+// activation.setParameter("max", "10");
+// QProfileDto profileDto = get(XOO_P1_NAME);
+// tester.get(RuleActivator.class).activate(dbSession, activation, profileDto);
+//
+// activation = new RuleActivation(XOO_X2);
+// activation.setSeverity(Severity.INFO);
+// tester.get(RuleActivator.class).activate(dbSession, activation, profileDto);
+// dbSession.commit();
+// dbSession.clearCache();
+// activeRuleIndexer.index();
+//
+// // restore backup, which activates only x1
+// // -> update x1 and deactivate x2
+// tester.get(QProfileBackuper.class).restore(dbSession, new StringReader(
+// Resources.toString(getClass().getResource("QProfileBackuperMediumTest/restore.xml"), StandardCharsets.UTF_8)), organization, null);
+//
+// // Check in db
+// List<ActiveRuleDto> activeRules = db.activeRuleDao().selectByProfileUuid(dbSession, XOO_P1_KEY);
+// assertThat(activeRules).hasSize(1);
+// ActiveRuleDto activeRuleDoc = activeRules.get(0);
+// assertThat(activeRuleDoc.getSeverityString()).isEqualTo("BLOCKER");
+// assertThat(activeRuleDoc.getInheritance()).isNull();
+//
+// ActiveRuleDto activeRuleDto = db.activeRuleDao().selectOrFailByKey(dbSession, activeRuleDoc.getKey());
+
// List<ActiveRuleParamDto> params = tester.get(ActiveRuleDao.class).selectParamsByActiveRuleId(dbSession, activeRuleDto.getId());
+// assertThat(params).hasSize(1);
+// assertThat(params.get(0).getKey()).isEqualTo("max");
+// assertThat(params.get(0).getValue()).isEqualTo("7");
+//
+// // Check in es
+// assertThat(tester.get(RuleIndex.class).searchAll(new RuleQuery().setQProfileKey(XOO_P1_KEY).setActivation(true))).containsOnly(XOO_X1);
+// }
+//
+// @Test
+// public void restore_child_profile() throws Exception {
+// // define two parent/child profiles
+// db.qualityProfileDao().insert(dbSession,
+// newXooP1(organization),
+// newXooP2(organization).setParentKee(XOO_P1_KEY));
+// dbSession.commit();
+//
+// // rule x1 is activated on parent profile (so inherited by child profile)
+// RuleActivation activation = new RuleActivation(XOO_X1);
+// activation.setSeverity(Severity.INFO);
+// activation.setParameter("max", "10");
+// tester.get(RuleActivator.class).activate(dbSession, activation, XOO_P1_KEY);
+// dbSession.commit();
+// dbSession.clearCache();
+// activeRuleIndexer.index();
+//
+// // restore backup of child profile -> overrides x1
+// tester.get(QProfileBackuper.class).restore(dbSession, new StringReader(
+// Resources.toString(getClass().getResource("QProfileBackuperMediumTest/restore-child.xml"), StandardCharsets.UTF_8)), organization, null);
+//
+// // parent profile is unchanged
+// List<ActiveRuleDto> activeRules = db.activeRuleDao().selectByProfileUuid(dbSession, XOO_P1_KEY);
+// assertThat(activeRules).hasSize(1);
+// ActiveRuleDto activeRuleDoc = activeRules.get(0);
+// assertThat(activeRuleDoc.getSeverityString()).isEqualTo("INFO");
+// assertThat(activeRuleDoc.getInheritance()).isNull();
+//
+// ActiveRuleDto activeRuleDto = db.activeRuleDao().selectOrFailByKey(dbSession, activeRuleDoc.getKey());
+
// List<ActiveRuleParamDto> params = tester.get(ActiveRuleDao.class).selectParamsByActiveRuleId(dbSession, activeRuleDto.getId());
+// assertThat(params).hasSize(1);
+// assertThat(params.get(0).getKey()).isEqualTo("max");
+// assertThat(params.get(0).getValue()).isEqualTo("10");
+//
+// // child profile overrides parent
+// activeRules = db.activeRuleDao().selectByProfileUuid(dbSession, XOO_P2_KEY);
+// assertThat(activeRules).hasSize(1);
+// activeRuleDoc = activeRules.get(0);
+// assertThat(activeRuleDoc.getSeverityString()).isEqualTo("BLOCKER");
+// assertThat(activeRuleDoc.getInheritance()).isEqualTo(OVERRIDES);
+//
+// activeRuleDto = db.activeRuleDao().selectOrFailByKey(dbSession, activeRuleDoc.getKey());
+// params = tester.get(ActiveRuleDao.class).selectParamsByActiveRuleId(dbSession, activeRuleDto.getId());
+// assertThat(params).hasSize(1);
+// assertThat(params.get(0).getKey()).isEqualTo("max");
+// assertThat(params.get(0).getValue()).isEqualTo("7");
+// }
+//
+// @Test
+// public void restore_parent_profile() throws Exception {
+// // define two parent/child profiles
+// db.qualityProfileDao().insert(dbSession,
+// newXooP1(organization),
+// newXooP2(organization).setParentKee(XOO_P1_KEY));
+// dbSession.commit();
+//
+// // rule x1 is activated on parent profile (so inherited by child profile)
+// RuleActivation activation = new RuleActivation(XOO_X1);
+// activation.setSeverity(Severity.INFO);
+// activation.setParameter("max", "10");
+// tester.get(RuleActivator.class).activate(dbSession, activation, XOO_P1_KEY);
+// dbSession.commit();
+// dbSession.clearCache();
+// activeRuleIndexer.index();
+//
+// // restore backup of parent profile -> update x1 and propagates to child
+// tester.get(QProfileBackuper.class).restore(dbSession, new StringReader(
+// Resources.toString(getClass().getResource("QProfileBackuperMediumTest/restore-parent.xml"), StandardCharsets.UTF_8)), organization, null);
+//
+// // parent profile is updated
+// List<ActiveRuleDto> activeRules = db.activeRuleDao().selectByProfileUuid(dbSession, XOO_P1_KEY);
+// assertThat(activeRules).hasSize(1);
+//
+// ActiveRuleDto activeRuleDoc = activeRules.get(0);
+// assertThat(activeRuleDoc.getSeverityString()).isEqualTo("BLOCKER");
+// assertThat(activeRuleDoc.getInheritance()).isNull();
+//
+// ActiveRuleDto activeRuleDto = db.activeRuleDao().selectOrFailByKey(dbSession, activeRuleDoc.getKey());
+
// List<ActiveRuleParamDto> params = tester.get(ActiveRuleDao.class).selectParamsByActiveRuleId(dbSession, activeRuleDto.getId());
+// assertThat(params).hasSize(1);
+// assertThat(params.get(0).getKey()).isEqualTo("max");
+// assertThat(params.get(0).getValue()).isEqualTo("7");
+//
+// // child profile is inherited
+// activeRules = db.activeRuleDao().selectByProfileUuid(dbSession, XOO_P2_KEY);
+// assertThat(activeRules).hasSize(1);
+// activeRuleDoc = activeRules.get(0);
+// assertThat(activeRuleDoc.getSeverityString()).isEqualTo("BLOCKER");
+// assertThat(activeRuleDoc.getInheritance()).isEqualTo(INHERITED);
+//
+// activeRuleDto = db.activeRuleDao().selectOrFailByKey(dbSession, activeRuleDoc.getKey());
+// params = tester.get(ActiveRuleDao.class).selectParamsByActiveRuleId(dbSession, activeRuleDto.getId());
+// assertThat(params).hasSize(1);
+// assertThat(params.get(0).getKey()).isEqualTo("max");
+// assertThat(params.get(0).getValue()).isEqualTo("7");
+// }
+//
+// @Test
+// public void keep_other_inherited_rules() throws Exception {
+// // define two parent/child profiles
+// db.qualityProfileDao().insert(dbSession,
+// newXooP1(organization),
+// newXooP2(organization).setParentKee(XOO_P1_KEY));
+// dbSession.commit();
+//
+// // rule x1 is activated on parent profile and is inherited by child profile
+// RuleActivation activation = new RuleActivation(XOO_X1);
+// activation.setSeverity(Severity.INFO);
+// activation.setParameter("max", "10");
+// tester.get(RuleActivator.class).activate(dbSession, activation, XOO_P1_KEY);
+// dbSession.commit();
+// dbSession.clearCache();
+// activeRuleIndexer.index();
+//
+// // backup of child profile contains x2 but not x1
+// tester.get(QProfileBackuper.class).restore(dbSession, new StringReader(
+// Resources.toString(getClass().getResource("QProfileBackuperMediumTest/keep_other_inherited_rules.xml"), StandardCharsets.UTF_8)), organization, XOO_P2_NAME.getName());
+//
+// // x1 and x2
+// assertThat(db.activeRuleDao().selectByProfileUuid(dbSession, XOO_P2_KEY)).hasSize(2);
+// }
+//
+// @Test
+// public void fail_to_restore_if_not_xml_backup() throws Exception {
+// try {
+// tester.get(QProfileBackuper.class).restore(dbSession, new StringReader(
+// Resources.toString(getClass().getResource("QProfileBackuperMediumTest/not-xml-backup.txt"), StandardCharsets.UTF_8)), organization, null);
+// fail();
+// } catch (IllegalStateException e) {
+// assertThat(e).hasMessage("Fail to restore Quality profile backup");
+// assertThat(e.getCause()).isInstanceOf(XMLStreamException.class);
+// }
+// }
+//
+// @Test
+// public void fail_to_restore_if_bad_xml_format() throws Exception {
+// try {
+// tester.get(QProfileBackuper.class).restore(dbSession, new StringReader(
+// Resources.toString(getClass().getResource("QProfileBackuperMediumTest/bad-xml-backup.xml"), StandardCharsets.UTF_8)), organization, null);
+// fail();
+// } catch (IllegalArgumentException e) {
+
// assertThat(e).hasMessage("Backup XML is not valid. Root element must be <profile>.");
+// }
+// }
+//
+// @Test
+// public void fail_to_restore_if_duplicate_rule() throws Exception {
+// try {
+// tester.get(QProfileBackuper.class).restore(dbSession, new StringReader(
+// Resources.toString(getClass().getResource("QProfileBackuperMediumTest/duplicates-xml-backup.xml"), StandardCharsets.UTF_8)), organization, null);
+// fail();
+// } catch (IllegalArgumentException e) {
+// assertThat(e).hasMessage("The quality profile cannot be restored as it contains duplicates for the following rules: xoo:x1, xoo:x2");
+// }
+// }
+//
+// @Test
+// public void restore_and_override_profile_name() throws Exception {
+// tester.get(QProfileBackuper.class).restore(dbSession, new StringReader(
+// Resources.toString(getClass().getResource("QProfileBackuperMediumTest/restore.xml"), StandardCharsets.UTF_8)),
+// organization, XOO_P3_NAME.getName());
+//
+// List<ActiveRuleDto> activeRules = db.activeRuleDao().selectByProfileUuid(dbSession, XOO_P1_KEY);
+// assertThat(activeRules).hasSize(0);
+//
+// QProfileDto target = db.qualityProfileDao().selectByNameAndLanguage(dbSession, organization, "P3", "xoo");
+// assertThat(target).isNotNull();
+// assertThat(db.activeRuleDao().selectByProfileUuid(dbSession, target.getKee())).hasSize(1);
+// }
+//
+// @Test
+// public void restore_profile_with_zero_rules() throws Exception {
+// tester.get(QProfileBackuper.class).restore(dbSession, new StringReader(
+// Resources.toString(getClass().getResource("QProfileBackuperMediumTest/empty.xml"), StandardCharsets.UTF_8)),
+// organization, null);
+//
+// dbSession.clearCache();
+// assertThat(anyActiveRuleExists()).isFalse();
+// List<QProfileDto> profiles = db.qualityProfileDao().selectOrderedByOrganizationUuid(dbSession, organization);
+// assertThat(profiles).hasSize(1);
+// assertThat(profiles.get(0).getName()).isEqualTo("P1");
+// }
+//
+// private boolean anyActiveRuleExists() throws SQLException {
+// try (PreparedStatement preparedStatement = db.openSession(false).getConnection().prepareStatement("SELECT * FROM active_rules");
+// ResultSet resultSet = preparedStatement.executeQuery();) {
+// return resultSet.next();
+// }
+// }
+//
+// private QProfileDto get(QProfileName profileName) {
+// return db.qualityProfileDao().selectByNameAndLanguage(dbSession, organization, profileName.getName(), profileName.getLanguage());
+// }
}
*/
package org.sonar.server.qualityprofile;
-import com.google.common.collect.ImmutableMap;
-import java.util.List;
-import java.util.Map;
-import javax.annotation.Nullable;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.ClassRule;
-import org.junit.Rule;
-import org.junit.Test;
-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.organization.OrganizationDto;
-import org.sonar.db.qualityprofile.ActiveRuleDto;
-import org.sonar.db.qualityprofile.ActiveRuleParamDto;
-import org.sonar.db.qualityprofile.QProfileDto;
-import org.sonar.db.rule.RuleDefinitionDto;
-import org.sonar.db.rule.RuleDto;
-import org.sonar.db.rule.RuleParamDto;
-import org.sonar.db.rule.RuleTesting;
-import org.sonar.server.qualityprofile.index.ActiveRuleIndexer;
-import org.sonar.server.rule.index.RuleIndex;
-import org.sonar.server.rule.index.RuleIndexer;
-import org.sonar.server.rule.index.RuleQuery;
-import org.sonar.server.tester.ServerTester;
-import org.sonar.server.tester.UserSessionRule;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.fail;
-import static org.sonar.server.qualityprofile.QProfileTesting.getDefaultOrganization;
-
public class QProfileCopierMediumTest {
- @ClassRule
- public static ServerTester tester = new ServerTester().withEsIndexes();
- @Rule
- public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
-
- private DbClient db;
- private DbSession dbSession;
- private RuleActivator ruleActivator;
- private QProfileCopier copier;
- private RuleIndexer ruleIndexer;
- private ActiveRuleIndexer activeRuleIndexer;
- private OrganizationDto organization;
- private QProfileDto sourceProfile;
-
- @Before
- public void before() {
- tester.clearDbAndIndexes();
- db = tester.get(DbClient.class);
- dbSession = db.openSession(false);
- ruleActivator = tester.get(RuleActivator.class);
- copier = tester.get(QProfileCopier.class);
- ruleIndexer = tester.get(RuleIndexer.class);
- activeRuleIndexer = tester.get(ActiveRuleIndexer.class);
- organization = getDefaultOrganization(tester, db, dbSession);
-
- // create pre-defined rules
- RuleDto xooRule1 = RuleTesting.newXooX1().setSeverity("MINOR");
- RuleDefinitionDto xooRule1Definition = xooRule1.getDefinition();
- db.ruleDao().insert(dbSession, xooRule1Definition);
- db.ruleDao().insertRuleParam(dbSession, xooRule1Definition, RuleParamDto.createFor(xooRule1Definition)
- .setName("max").setDefaultValue("10").setType(RuleParamType.INTEGER.type()));
- dbSession.commit();
- ruleIndexer.indexRuleDefinition(xooRule1Definition.getKey());
-
- RuleDto xooRule2 = RuleTesting.newXooX2().setSeverity("MAJOR");
- RuleDefinitionDto xooRule2Definition = xooRule2.getDefinition();
- db.ruleDao().insert(dbSession, xooRule2Definition);
- dbSession.commit();
- ruleIndexer.indexRuleDefinition(xooRule2Definition.getKey());
-
- // create pre-defined profile
- sourceProfile = QProfileTesting.newXooP1(organization);
- db.qualityProfileDao().insert(dbSession, sourceProfile);
- dbSession.commit();
- }
-
- @After
- public void after() {
- dbSession.close();
- }
-
- @Test
- public void create_target_profile() {
- // source
- RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1);
- activation.setSeverity(Severity.BLOCKER);
- activation.setParameter("max", "7");
- ruleActivator.activate(dbSession, activation, QProfileTesting.XOO_P1_KEY);
- dbSession.commit();
- dbSession.clearCache();
- activeRuleIndexer.index();
-
- // target does not exist
- copier.copyToName(dbSession, sourceProfile, QProfileTesting.XOO_P2_NAME.getName());
-
- verifyOneActiveRule(QProfileTesting.XOO_P2_NAME, Severity.BLOCKER, null, ImmutableMap.of("max", "7"));
- }
-
- @Test
- public void update_target_profile() {
- // source with x1 activated
- RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1);
- activation.setSeverity(Severity.BLOCKER);
- activation.setParameter("max", "7");
- ruleActivator.activate(dbSession, activation, QProfileTesting.XOO_P1_KEY);
- dbSession.commit();
- dbSession.clearCache();
- activeRuleIndexer.index();
-
- // create target with both x1 and x2 activated
- db.qualityProfileDao().insert(dbSession, QProfileTesting.newXooP2(organization));
- activation = new RuleActivation(RuleTesting.XOO_X1);
- activation.setSeverity(Severity.CRITICAL);
- activation.setParameter("max", "20");
- ruleActivator.activate(dbSession, activation, QProfileTesting.XOO_P2_KEY);
- activation = new RuleActivation(RuleTesting.XOO_X2);
- activation.setSeverity(Severity.CRITICAL);
- ruleActivator.activate(dbSession, activation, QProfileTesting.XOO_P2_KEY);
- dbSession.commit();
- dbSession.clearCache();
- activeRuleIndexer.index();
-
- // copy -> reset x1 and deactivate x2
- copier.copyToName(dbSession, sourceProfile, QProfileTesting.XOO_P2_NAME.getName());
-
- verifyOneActiveRule(QProfileTesting.XOO_P2_KEY, Severity.BLOCKER, null, ImmutableMap.of("max", "7"));
- }
-
- @Test
- public void create_target_profile_with_same_parent_than_source() {
- // two profiles : parent and its child
- db.qualityProfileDao().insert(dbSession, QProfileTesting.newXooP2(organization).setParentKee(QProfileTesting.XOO_P1_KEY));
-
- // parent and child with x1 activated
- RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1);
- activation.setSeverity(Severity.BLOCKER);
- activation.setParameter("max", "7");
- ruleActivator.activate(dbSession, activation, QProfileTesting.XOO_P1_KEY);
- dbSession.commit();
- dbSession.clearCache();
- activeRuleIndexer.index();
-
- // copy child -> profile2 is created with parent P1
- copier.copyToName(dbSession, sourceProfile, QProfileTesting.XOO_P2_NAME.getName());
-
- verifyOneActiveRule(QProfileTesting.XOO_P2_KEY, Severity.BLOCKER, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "7"));
- QProfileDto profile2Dto = db.qualityProfileDao().selectByUuid(dbSession, QProfileTesting.XOO_P2_KEY);
- assertThat(profile2Dto.getParentKee()).isEqualTo(QProfileTesting.XOO_P1_KEY);
- }
-
- @Test
- public void fail_to_copy_on_self() {
- RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1);
- activation.setSeverity(Severity.BLOCKER);
- activation.setParameter("max", "7");
- ruleActivator.activate(dbSession, activation, QProfileTesting.XOO_P1_KEY);
- dbSession.commit();
- dbSession.clearCache();
- activeRuleIndexer.index();
-
- try {
- copier.copyToName(dbSession, sourceProfile, QProfileTesting.XOO_P1_NAME.getName());
- fail();
- } catch (IllegalArgumentException e) {
- assertThat(e).hasMessage("Source and target profiles are equal: P1");
- }
- }
-
- private void verifyOneActiveRule(QProfileName profileName, String expectedSeverity,
- @Nullable String expectedInheritance, Map<String, String> expectedParams) {
- QProfileDto dto = db.qualityProfileDao().selectByNameAndLanguage(dbSession, organization, profileName.getName(), profileName.getLanguage());
- verifyOneActiveRule(dto.getKee(), expectedSeverity, expectedInheritance, expectedParams);
- }
-
- private void verifyOneActiveRule(String profileKey, String expectedSeverity, @Nullable String expectedInheritance, Map<String, String> expectedParams) {
-
- // check in db
- List<ActiveRuleDto> activeRules = db.activeRuleDao().selectByProfileKey(dbSession, profileKey);
- assertThat(activeRules).hasSize(1);
-
- ActiveRuleDto activeRule = activeRules.get(0);
- assertThat(activeRule.getSeverityString()).isEqualTo(expectedSeverity);
- assertThat(activeRule.getInheritance()).isEqualTo(expectedInheritance);
-
- // verify parameters
- ActiveRuleDto activeRuleDto = db.activeRuleDao().selectOrFailByKey(dbSession, activeRule.getKey());
- List<ActiveRuleParamDto> params = db.activeRuleDao().selectParamsByActiveRuleId(dbSession, activeRuleDto.getId());
- assertThat(params).hasSize(expectedParams.size());
- Map<String, ActiveRuleParamDto> paramsByKey = ActiveRuleParamDto.groupByKey(params);
- for (Map.Entry<String, String> entry : expectedParams.entrySet()) {
- String value = paramsByKey.get(entry.getKey()).getValue();
- assertThat(value).isEqualTo(entry.getValue());
- }
-
- // check in es
- assertThat(tester.get(RuleIndex.class).searchAll(new RuleQuery().setQProfileKey(profileKey).setActivation(true))).hasSize(1);
- }
+// @ClassRule
+// public static ServerTester tester = new ServerTester().withEsIndexes();
+// @Rule
+// public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
+//
+// private DbClient db;
+// private DbSession dbSession;
+// private RuleActivator ruleActivator;
+// private QProfileCopier copier;
+// private RuleIndexer ruleIndexer;
+// private ActiveRuleIndexer activeRuleIndexer;
+// private OrganizationDto organization;
+// private QProfileDto sourceProfile;
+//
+// @Before
+// public void before() {
+// tester.clearDbAndIndexes();
+// db = tester.get(DbClient.class);
+// dbSession = db.openSession(false);
+// ruleActivator = tester.get(RuleActivator.class);
+// copier = tester.get(QProfileCopier.class);
+// ruleIndexer = tester.get(RuleIndexer.class);
+// activeRuleIndexer = tester.get(ActiveRuleIndexer.class);
+// organization = getDefaultOrganization(tester, db, dbSession);
+//
+// // create pre-defined rules
+// RuleDto xooRule1 = RuleTesting.newXooX1().setSeverity("MINOR");
+// RuleDefinitionDto xooRule1Definition = xooRule1.getDefinition();
+// db.ruleDao().insert(dbSession, xooRule1Definition);
+// db.ruleDao().insertRuleParam(dbSession, xooRule1Definition, RuleParamDto.createFor(xooRule1Definition)
+// .setName("max").setDefaultValue("10").setType(RuleParamType.INTEGER.type()));
+// dbSession.commit();
+// ruleIndexer.indexRuleDefinition(xooRule1Definition.getKey());
+//
+// RuleDto xooRule2 = RuleTesting.newXooX2().setSeverity("MAJOR");
+// RuleDefinitionDto xooRule2Definition = xooRule2.getDefinition();
+// db.ruleDao().insert(dbSession, xooRule2Definition);
+// dbSession.commit();
+// ruleIndexer.indexRuleDefinition(xooRule2Definition.getKey());
+//
+// // create pre-defined profile
+// sourceProfile = QProfileTesting.newXooP1(organization);
+// db.qualityProfileDao().insert(dbSession, sourceProfile);
+// dbSession.commit();
+// }
+//
+// @After
+// public void after() {
+// dbSession.close();
+// }
+//
+// @Test
+// public void create_target_profile() {
+// // source
+// RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1);
+// activation.setSeverity(Severity.BLOCKER);
+// activation.setParameter("max", "7");
+// ruleActivator.activate(dbSession, activation, QProfileTesting.XOO_P1_KEY);
+// dbSession.commit();
+// dbSession.clearCache();
+// activeRuleIndexer.index();
+//
+// // target does not exist
+// copier.copyToName(dbSession, sourceProfile, QProfileTesting.XOO_P2_NAME.getName());
+//
+// verifyOneActiveRule(QProfileTesting.XOO_P2_NAME, Severity.BLOCKER, null, ImmutableMap.of("max", "7"));
+// }
+//
+// @Test
+// public void update_target_profile() {
+// // source with x1 activated
+// RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1);
+// activation.setSeverity(Severity.BLOCKER);
+// activation.setParameter("max", "7");
+// ruleActivator.activate(dbSession, activation, QProfileTesting.XOO_P1_KEY);
+// dbSession.commit();
+// dbSession.clearCache();
+// activeRuleIndexer.index();
+//
+// // create target with both x1 and x2 activated
+// db.qualityProfileDao().insert(dbSession, QProfileTesting.newXooP2(organization));
+// activation = new RuleActivation(RuleTesting.XOO_X1);
+// activation.setSeverity(Severity.CRITICAL);
+// activation.setParameter("max", "20");
+// ruleActivator.activate(dbSession, activation, QProfileTesting.XOO_P2_KEY);
+// activation = new RuleActivation(RuleTesting.XOO_X2);
+// activation.setSeverity(Severity.CRITICAL);
+// ruleActivator.activate(dbSession, activation, QProfileTesting.XOO_P2_KEY);
+// dbSession.commit();
+// dbSession.clearCache();
+// activeRuleIndexer.index();
+//
+// // copy -> reset x1 and deactivate x2
+// copier.copyToName(dbSession, sourceProfile, QProfileTesting.XOO_P2_NAME.getName());
+//
+// verifyOneActiveRule(QProfileTesting.XOO_P2_KEY, Severity.BLOCKER, null, ImmutableMap.of("max", "7"));
+// }
+//
+// @Test
+// public void create_target_profile_with_same_parent_than_source() {
+// // two profiles : parent and its child
+// db.qualityProfileDao().insert(dbSession, QProfileTesting.newXooP2(organization).setParentKee(QProfileTesting.XOO_P1_KEY));
+//
+// // parent and child with x1 activated
+// RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1);
+// activation.setSeverity(Severity.BLOCKER);
+// activation.setParameter("max", "7");
+// ruleActivator.activate(dbSession, activation, QProfileTesting.XOO_P1_KEY);
+// dbSession.commit();
+// dbSession.clearCache();
+// activeRuleIndexer.index();
+//
+// // copy child -> profile2 is created with parent P1
+// copier.copyToName(dbSession, sourceProfile, QProfileTesting.XOO_P2_NAME.getName());
+//
+// verifyOneActiveRule(QProfileTesting.XOO_P2_KEY, Severity.BLOCKER, ActiveRuleDto.INHERITED, ImmutableMap.of("max", "7"));
+// QProfileDto profile2Dto = db.qualityProfileDao().selectByUuid(dbSession, QProfileTesting.XOO_P2_KEY);
+// assertThat(profile2Dto.getParentKee()).isEqualTo(QProfileTesting.XOO_P1_KEY);
+// }
+//
+// @Test
+// public void fail_to_copy_on_self() {
+// RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1);
+// activation.setSeverity(Severity.BLOCKER);
+// activation.setParameter("max", "7");
+// ruleActivator.activate(dbSession, activation, QProfileTesting.XOO_P1_KEY);
+// dbSession.commit();
+// dbSession.clearCache();
+// activeRuleIndexer.index();
+//
+// try {
+// copier.copyToName(dbSession, sourceProfile, QProfileTesting.XOO_P1_NAME.getName());
+// fail();
+// } catch (IllegalArgumentException e) {
+// assertThat(e).hasMessage("Source and target profiles are equal: P1");
+// }
+// }
+//
+// private void verifyOneActiveRule(QProfileName profileName, String expectedSeverity,
+// @Nullable String expectedInheritance, Map<String, String> expectedParams) {
+// QProfileDto dto = db.qualityProfileDao().selectByNameAndLanguage(dbSession, organization, profileName.getName(), profileName.getLanguage());
+// verifyOneActiveRule(dto.getKee(), expectedSeverity, expectedInheritance, expectedParams);
+// }
+//
+// private void verifyOneActiveRule(String profileKey, String expectedSeverity, @Nullable String expectedInheritance, Map<String, String> expectedParams) {
+//
+// // check in db
+// List<ActiveRuleDto> activeRules = db.activeRuleDao().selectByProfileUuid(dbSession, profileKey);
+// assertThat(activeRules).hasSize(1);
+//
+// ActiveRuleDto activeRule = activeRules.get(0);
+// assertThat(activeRule.getSeverityString()).isEqualTo(expectedSeverity);
+// assertThat(activeRule.getInheritance()).isEqualTo(expectedInheritance);
+//
+// // verify parameters
+// ActiveRuleDto activeRuleDto = db.activeRuleDao().selectOrFailByKey(dbSession, activeRule.getKey());
+
// List<ActiveRuleParamDto> params = db.activeRuleDao().selectParamsByActiveRuleId(dbSession, activeRuleDto.getId());
+// assertThat(params).hasSize(expectedParams.size());
+// Map<String, ActiveRuleParamDto> paramsByKey = ActiveRuleParamDto.groupByKey(params);
+// for (Map.Entry<String, String> entry : expectedParams.entrySet()) {
+// String value = paramsByKey.get(entry.getKey()).getValue();
+// assertThat(value).isEqualTo(entry.getValue());
+// }
+//
+// // check in es
+// assertThat(tester.get(RuleIndex.class).searchAll(new RuleQuery().setQProfileKey(profileKey).setActivation(true))).hasSize(1);
+// }
}
*/
package org.sonar.server.qualityprofile;
-import java.io.IOException;
-import java.io.Reader;
-import java.io.Writer;
-import java.util.List;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.ClassRule;
-import org.junit.Test;
-import org.sonar.api.profiles.ProfileDefinition;
-import org.sonar.api.profiles.ProfileExporter;
-import org.sonar.api.profiles.ProfileImporter;
-import org.sonar.api.profiles.RulesProfile;
-import org.sonar.api.rule.RuleKey;
-import org.sonar.api.rule.Severity;
-import org.sonar.api.rules.Rule;
-import org.sonar.api.rules.RulePriority;
-import org.sonar.api.server.rule.RuleParamType;
-import org.sonar.api.server.rule.RulesDefinition;
-import org.sonar.api.utils.ValidationMessages;
-import org.sonar.db.DbClient;
-import org.sonar.db.DbSession;
-import org.sonar.db.qualityprofile.ActiveRuleDto;
-import org.sonar.db.qualityprofile.QProfileDto;
-import org.sonar.server.exceptions.BadRequestException;
-import org.sonar.server.qualityprofile.index.ActiveRuleIndexer;
-import org.sonar.server.rule.index.RuleIndex;
-import org.sonar.server.rule.index.RuleQuery;
-import org.sonar.server.tester.ServerTester;
-import org.sonar.server.tester.UserSessionRule;
-
-import static java.nio.charset.StandardCharsets.UTF_8;
-import static org.apache.commons.io.IOUtils.toInputStream;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.fail;
-
public class QProfileExportersTest {
- @ClassRule
- public static ServerTester tester = new ServerTester()
- .withEsIndexes()
- .withStartupTasks()
- .addXoo()
- .addComponents(XooRulesDefinition.class, XooProfileDefinition.class, XooExporter.class, StandardExporter.class,
- XooProfileImporter.class, XooProfileImporterWithMessages.class, XooProfileImporterWithError.class);
-
- @org.junit.Rule
- public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
-
- DbClient db;
- DbSession dbSession;
- QProfileExporters exporters;
- ActiveRuleIndexer activeRuleIndexer;
-
- @Before
- public void before() {
- db = tester.get(DbClient.class);
- dbSession = db.openSession(false);
- exporters = tester.get(QProfileExporters.class);
- activeRuleIndexer = tester.get(ActiveRuleIndexer.class);
- }
-
- @After
- public void after() {
- dbSession.close();
- }
-
- @Test
- public void exportersForLanguage() {
- assertThat(exporters.exportersForLanguage("xoo")).hasSize(2);
- assertThat(exporters.exportersForLanguage("java")).hasSize(1);
- assertThat(exporters.exportersForLanguage("java").get(0)).isInstanceOf(StandardExporter.class);
- }
-
- @Test
- public void mimeType() {
- assertThat(exporters.mimeType("xootool")).isEqualTo("plain/custom");
-
- // default mime type
- assertThat(exporters.mimeType("standard")).isEqualTo("text/plain");
- }
-
- @Test
- public void import_xml() {
- QProfileDto profileDto = QProfileTesting.newQProfileDto("org-123", QProfileName.createFor("xoo", "import_xml"), "import_xml");
- db.qualityProfileDao().insert(dbSession, profileDto);
- dbSession.commit();
-
- assertThat(db.activeRuleDao().selectByProfileKey(dbSession, profileDto.getKee())).isEmpty();
-
- QProfileResult result = exporters.importXml(profileDto, "XooProfileImporter", toInputStream("<xml/>", UTF_8), dbSession);
- dbSession.commit();
- activeRuleIndexer.index(result.getChanges());
-
- // Check in db
- List<ActiveRuleDto> activeRules = db.activeRuleDao().selectByProfileKey(dbSession, profileDto.getKee());
- assertThat(activeRules).hasSize(1);
- ActiveRuleDto activeRule = activeRules.get(0);
- assertThat(activeRule.getKey().ruleKey()).isEqualTo(RuleKey.of("xoo", "R1"));
- assertThat(activeRule.getSeverityString()).isEqualTo(Severity.CRITICAL);
-
- // Check in es
- assertThat(tester.get(RuleIndex.class).searchAll(new RuleQuery().setQProfileKey(profileDto.getKee()).setActivation(true))).containsOnly(RuleKey.of("xoo", "R1"));
- }
-
- @Test
- public void import_xml_return_messages() {
- QProfileResult result = exporters.importXml(QProfileTesting.newXooP1("org-123"), "XooProfileImporterWithMessages", toInputStream("<xml/>", UTF_8), dbSession);
- dbSession.commit();
-
- assertThat(result.infos()).containsOnly("an info");
- assertThat(result.warnings()).containsOnly("a warning");
- }
-
- @Test
- public void fail_to_import_xml_when_error_in_importer() {
- try {
- exporters.importXml(QProfileTesting.newXooP1("org-123"), "XooProfileImporterWithError", toInputStream("<xml/>", UTF_8), dbSession);
- fail();
- } catch (Exception e) {
- assertThat(e).isInstanceOf(BadRequestException.class).hasMessage("error!");
- }
- }
-
- @Test
- public void fail_to_import_xml_on_unknown_importer() {
- try {
- exporters.importXml(QProfileTesting.newXooP1("org-123"), "Unknown", toInputStream("<xml/>", UTF_8), dbSession);
- fail();
- } catch (Exception e) {
- assertThat(e).isInstanceOf(BadRequestException.class).hasMessage("No such importer : Unknown");
- }
- }
-
- public static class XooExporter extends ProfileExporter {
- public XooExporter() {
- super("xootool", "Xoo Tool");
- }
-
- @Override
- public String[] getSupportedLanguages() {
- return new String[] {"xoo"};
- }
-
- @Override
- public String getMimeType() {
- return "plain/custom";
- }
-
- @Override
- public void exportProfile(RulesProfile profile, Writer writer) {
- try {
- writer.write("xoo -> " + profile.getName() + " -> " + profile.getActiveRules().size());
- } catch (IOException e) {
- throw new IllegalStateException(e);
- }
- }
- }
-
- public static class StandardExporter extends ProfileExporter {
- public StandardExporter() {
- super("standard", "Standard");
- }
-
- @Override
- public void exportProfile(RulesProfile profile, Writer writer) {
- try {
- writer.write("standard -> " + profile.getName() + " -> " + profile.getActiveRules().size());
- } catch (IOException e) {
- throw new IllegalStateException(e);
- }
- }
- }
-
- public static class XooRulesDefinition implements RulesDefinition {
- @Override
- public void define(Context context) {
- NewRepository repository = context.createRepository("xoo", "xoo").setName("Xoo Repo");
- NewRule x1 = repository.createRule("R1")
- .setName("R1 name")
- .setHtmlDescription("R1 desc")
- .setSeverity(Severity.MINOR);
- x1.createParam("acceptWhitespace")
- .setDefaultValue("false")
- .setType(RuleParamType.BOOLEAN)
- .setDescription("Accept whitespaces on the line");
- repository.done();
- }
- }
-
- public static class XooProfileDefinition extends ProfileDefinition {
- @Override
- public RulesProfile createProfile(ValidationMessages validation) {
- RulesProfile profile = RulesProfile.create("P1", "xoo");
- profile.activateRule(new Rule("xoo", "R1"), RulePriority.BLOCKER).setParameter("acceptWhitespace", "true");
- return profile;
- }
- }
-
- public static class XooProfileImporter extends ProfileImporter {
- public XooProfileImporter() {
- super("XooProfileImporter", "Xoo Profile Importer");
- }
-
- @Override
- public String[] getSupportedLanguages() {
- return new String[] {"xoo"};
- }
-
- @Override
- public RulesProfile importProfile(Reader reader, ValidationMessages messages) {
- RulesProfile rulesProfile = RulesProfile.create();
- rulesProfile.activateRule(Rule.create("xoo", "R1"), RulePriority.CRITICAL);
- return rulesProfile;
- }
- }
-
- public static class XooProfileImporterWithMessages extends ProfileImporter {
- public XooProfileImporterWithMessages() {
- super("XooProfileImporterWithMessages", "Xoo Profile Importer With Message");
- }
-
- @Override
- public String[] getSupportedLanguages() {
- return new String[] {};
- }
-
- @Override
- public RulesProfile importProfile(Reader reader, ValidationMessages messages) {
- messages.addWarningText("a warning");
- messages.addInfoText("an info");
- return RulesProfile.create();
- }
- }
-
- public static class XooProfileImporterWithError extends ProfileImporter {
- public XooProfileImporterWithError() {
- super("XooProfileImporterWithError", "Xoo Profile Importer With Error");
- }
-
- @Override
- public RulesProfile importProfile(Reader reader, ValidationMessages messages) {
- messages.addErrorText("error!");
- return RulesProfile.create();
- }
- }
+// @ClassRule
+// public static ServerTester tester = new ServerTester()
+// .withEsIndexes()
+// .withStartupTasks()
+// .addXoo()
+// .addComponents(XooRulesDefinition.class, XooProfileDefinition.class, XooExporter.class, StandardExporter.class,
+// XooProfileImporter.class, XooProfileImporterWithMessages.class, XooProfileImporterWithError.class);
+//
+// @org.junit.Rule
+// public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
+//
+// private DbClient db;
+// private DbSession dbSession;
+// private QProfileExporters underTest;
+// private ActiveRuleIndexer activeRuleIndexer;
+//
+// @Before
+// public void before() {
+// db = tester.get(DbClient.class);
+// dbSession = db.openSession(false);
+// underTest = tester.get(QProfileExporters.class);
+// activeRuleIndexer = tester.get(ActiveRuleIndexer.class);
+// }
+//
+// @After
+// public void after() {
+// dbSession.close();
+// }
+//
+// @Test
+// public void exportersForLanguage() {
+// assertThat(underTest.exportersForLanguage("xoo")).hasSize(2);
+// assertThat(underTest.exportersForLanguage("java")).hasSize(1);
+// assertThat(underTest.exportersForLanguage("java").get(0)).isInstanceOf(StandardExporter.class);
+// }
+//
+// @Test
+// public void mimeType() {
+// assertThat(underTest.mimeType("xootool")).isEqualTo("plain/custom");
+//
+// // default mime type
+// assertThat(underTest.mimeType("standard")).isEqualTo("text/plain");
+// }
+//
+// @Test
+// public void import_xml() {
+// QProfileDto profile = QProfileTesting.newQProfileDto("org-123", QProfileName.createFor("xoo", "import_xml"), "import_xml");
+// db.qualityProfileDao().insert(dbSession, profile);
+// dbSession.commit();
+//
+// assertThat(db.activeRuleDao().selectByProfile(dbSession, profile)).isEmpty();
+//
+// QProfileResult result = underTest.importXml(profile, "XooProfileImporter", toInputStream("<xml/>", UTF_8), dbSession);
+// dbSession.commit();
+// activeRuleIndexer.index(result.getChanges());
+//
+// // Check in db
+// List<ActiveRuleDto> activeRules = db.activeRuleDao().selectByProfileUuid(dbSession, profile.getKee());
+// assertThat(activeRules).hasSize(1);
+// ActiveRuleDto activeRule = activeRules.get(0);
+// assertThat(activeRule.getKey().getRuleKey()).isEqualTo(RuleKey.of("xoo", "R1"));
+// assertThat(activeRule.getSeverityString()).isEqualTo(Severity.CRITICAL);
+//
+// // Check in es
+// assertThat(tester.get(RuleIndex.class).searchAll(new RuleQuery().setQProfile(profile).setActivation(true))).containsOnly(RuleKey.of("xoo", "R1"));
+// }
+//
+// @Test
+// public void import_xml_return_messages() {
+// QProfileResult result = underTest.importXml(QProfileTesting.newXooP1("org-123"), "XooProfileImporterWithMessages", toInputStream("<xml/>", UTF_8), dbSession);
+// dbSession.commit();
+//
+// assertThat(result.infos()).containsOnly("an info");
+// assertThat(result.warnings()).containsOnly("a warning");
+// }
+//
+// @Test
+// public void fail_to_import_xml_when_error_in_importer() {
+// try {
+// underTest.importXml(QProfileTesting.newXooP1("org-123"), "XooProfileImporterWithError", toInputStream("<xml/>", UTF_8), dbSession);
+// fail();
+// } catch (Exception e) {
+// assertThat(e).isInstanceOf(BadRequestException.class).hasMessage("error!");
+// }
+// }
+//
+// @Test
+// public void fail_to_import_xml_on_unknown_importer() {
+// try {
+// underTest.importXml(QProfileTesting.newXooP1("org-123"), "Unknown", toInputStream("<xml/>", UTF_8), dbSession);
+// fail();
+// } catch (Exception e) {
+// assertThat(e).isInstanceOf(BadRequestException.class).hasMessage("No such importer : Unknown");
+// }
+// }
+//
+// public static class XooExporter extends ProfileExporter {
+// public XooExporter() {
+// super("xootool", "Xoo Tool");
+// }
+//
+// @Override
+// public String[] getSupportedLanguages() {
+// return new String[] {"xoo"};
+// }
+//
+// @Override
+// public String getMimeType() {
+// return "plain/custom";
+// }
+//
+// @Override
+// public void exportProfile(RulesProfile profile, Writer writer) {
+// try {
+// writer.write("xoo -> " + profile.getName() + " -> " + profile.getActiveRules().size());
+// } catch (IOException e) {
+// throw new IllegalStateException(e);
+// }
+// }
+// }
+//
+// public static class StandardExporter extends ProfileExporter {
+// public StandardExporter() {
+// super("standard", "Standard");
+// }
+//
+// @Override
+// public void exportProfile(RulesProfile profile, Writer writer) {
+// try {
+// writer.write("standard -> " + profile.getName() + " -> " + profile.getActiveRules().size());
+// } catch (IOException e) {
+// throw new IllegalStateException(e);
+// }
+// }
+// }
+//
+// public static class XooRulesDefinition implements RulesDefinition {
+// @Override
+// public void define(Context context) {
+// NewRepository repository = context.createRepository("xoo", "xoo").setName("Xoo Repo");
+// NewRule x1 = repository.createRule("R1")
+// .setName("R1 name")
+// .setHtmlDescription("R1 desc")
+// .setSeverity(Severity.MINOR);
+// x1.createParam("acceptWhitespace")
+// .setDefaultValue("false")
+// .setType(RuleParamType.BOOLEAN)
+// .setDescription("Accept whitespaces on the line");
+// repository.done();
+// }
+// }
+//
+// public static class XooProfileDefinition extends ProfileDefinition {
+// @Override
+// public RulesProfile createProfile(ValidationMessages validation) {
+// RulesProfile profile = RulesProfile.create("P1", "xoo");
+// profile.activateRule(new Rule("xoo", "R1"), RulePriority.BLOCKER).setParameter("acceptWhitespace", "true");
+// return profile;
+// }
+// }
+//
+// public static class XooProfileImporter extends ProfileImporter {
+// public XooProfileImporter() {
+// super("XooProfileImporter", "Xoo Profile Importer");
+// }
+//
+// @Override
+// public String[] getSupportedLanguages() {
+// return new String[] {"xoo"};
+// }
+//
+// @Override
+// public RulesProfile importProfile(Reader reader, ValidationMessages messages) {
+// RulesProfile rulesProfile = RulesProfile.create();
+// rulesProfile.activateRule(Rule.create("xoo", "R1"), RulePriority.CRITICAL);
+// return rulesProfile;
+// }
+// }
+//
+// public static class XooProfileImporterWithMessages extends ProfileImporter {
+// public XooProfileImporterWithMessages() {
+// super("XooProfileImporterWithMessages", "Xoo Profile Importer With Message");
+// }
+//
+// @Override
+// public String[] getSupportedLanguages() {
+// return new String[] {};
+// }
+//
+// @Override
+// public RulesProfile importProfile(Reader reader, ValidationMessages messages) {
+// messages.addWarningText("a warning");
+// messages.addInfoText("an info");
+// return RulesProfile.create();
+// }
+// }
+//
+// public static class XooProfileImporterWithError extends ProfileImporter {
+// public XooProfileImporterWithError() {
+// super("XooProfileImporterWithError", "Xoo Profile Importer With Error");
+// }
+//
+// @Override
+// public RulesProfile importProfile(Reader reader, ValidationMessages messages) {
+// messages.addErrorText("error!");
+// return RulesProfile.create();
+// }
+// }
}
+++ /dev/null
-/*
- * SonarQube
- * Copyright (C) 2009-2017 SonarSource SA
- * mailto:info AT sonarsource DOT com
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 3 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-package org.sonar.server.qualityprofile;
-
-import org.junit.After;
-import org.junit.Before;
-import org.junit.ClassRule;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.sonar.db.DbClient;
-import org.sonar.db.DbSession;
-import org.sonar.db.organization.OrganizationDto;
-import org.sonar.db.organization.OrganizationTesting;
-import org.sonar.db.qualityprofile.QProfileDto;
-import org.sonar.server.exceptions.BadRequestException;
-import org.sonar.server.tester.ServerTester;
-import org.sonar.server.tester.UserSessionRule;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-public class QProfileFactoryMediumTest {
-
- @ClassRule
- public static ServerTester tester = new ServerTester().withEsIndexes();
- @Rule
- public ExpectedException thrown = ExpectedException.none();
- @Rule
- public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
-
- private DbClient db;
- private DbSession dbSession;
- private QProfileFactory factory;
- private OrganizationDto organization;
-
- @Before
- public void before() {
- tester.clearDbAndIndexes();
- db = tester.get(DbClient.class);
- dbSession = db.openSession(false);
- factory = tester.get(QProfileFactory.class);
- organization = OrganizationTesting.newOrganizationDto();
- db.organizationDao().insert(dbSession, organization, false);
- }
-
- @After
- public void after() {
- dbSession.close();
- }
-
- @Test
- public void checkAndCreate() {
- String uuid = organization.getUuid();
-
- QProfileDto writtenDto = factory.checkAndCreateCustom(dbSession, organization, new QProfileName("xoo", "P1"));
- dbSession.commit();
- dbSession.clearCache();
- assertThat(writtenDto.getOrganizationUuid()).isEqualTo(uuid);
- assertThat(writtenDto.getKee()).isNotEmpty();
- assertThat(writtenDto.getName()).isEqualTo("P1");
- assertThat(writtenDto.getLanguage()).isEqualTo("xoo");
- assertThat(writtenDto.getId()).isNotNull();
- assertThat(writtenDto.isBuiltIn()).isFalse();
-
- // reload the dto
- QProfileDto readDto = db.qualityProfileDao().selectByNameAndLanguage(dbSession, organization, "P1", "xoo");
- assertEqual(writtenDto, readDto);
-
- assertThat(db.qualityProfileDao().selectAll(dbSession, organization)).hasSize(1);
- }
-
- @Test
- public void create() {
- String uuid = organization.getUuid();
-
- QProfileDto writtenDto = factory.createBuiltIn(dbSession, organization, new QProfileName("xoo", "P1"), true);
- dbSession.commit();
- dbSession.clearCache();
- assertThat(writtenDto.getOrganizationUuid()).isEqualTo(uuid);
- assertThat(writtenDto.getKee()).isNotEmpty();
- assertThat(writtenDto.getName()).isEqualTo("P1");
- assertThat(writtenDto.getLanguage()).isEqualTo("xoo");
- assertThat(writtenDto.getId()).isNotNull();
- assertThat(writtenDto.getParentKee()).isNull();
-
- // reload the dto
- QProfileDto readDto = db.qualityProfileDao().selectByNameAndLanguage(dbSession, organization, "P1", "xoo");
- assertEqual(writtenDto, readDto);
-
- assertThat(db.qualityProfileDao().selectAll(dbSession, organization)).hasSize(1);
- }
-
- @Test
- public void checkAndCreate_throws_BadRequestException_if_name_null() {
- QProfileName name = new QProfileName("xoo", null);
-
- expectBadRequestException("quality_profiles.profile_name_cant_be_blank");
-
- factory.checkAndCreateCustom(dbSession, organization, name);
- }
-
- @Test
- public void checkAndCreate_throws_BadRequestException_if_name_empty() {
- QProfileName name = new QProfileName("xoo", "");
-
- expectBadRequestException("quality_profiles.profile_name_cant_be_blank");
-
- factory.checkAndCreateCustom(dbSession, organization, name);
- }
-
- @Test
- public void checkAndCreate_throws_BadRequestException_if_already_exists() {
- QProfileName name = new QProfileName("xoo", "P1");
- factory.checkAndCreateCustom(dbSession, organization, name);
- dbSession.commit();
- dbSession.clearCache();
-
- expectBadRequestException("Quality profile already exists: {lang=xoo, name=P1}");
-
- factory.checkAndCreateCustom(dbSession, organization, name);
- }
-
- @Test
- public void create_throws_BadRequestException_if_name_null() {
- QProfileName name = new QProfileName("xoo", null);
-
- expectBadRequestException("quality_profiles.profile_name_cant_be_blank");
-
- factory.createBuiltIn(dbSession, organization, name, true);
- }
-
- @Test
- public void create_throws_BadRequestException_if_name_empty() {
- QProfileName name = new QProfileName("xoo", "");
-
- expectBadRequestException("quality_profiles.profile_name_cant_be_blank");
-
- factory.createBuiltIn(dbSession, organization, name, false);
- }
-
- @Test
- public void create_does_not_fail_if_already_exists() {
- QProfileName name = new QProfileName("xoo", "P1");
- factory.createBuiltIn(dbSession, organization, name, true);
- dbSession.commit();
- dbSession.clearCache();
-
- assertThat(factory.createBuiltIn(dbSession, organization, name, true)).isNotNull();
- }
-
- private void expectBadRequestException(String message) {
- thrown.expect(BadRequestException.class);
- thrown.expectMessage(message);
- }
-
- private static void assertEqual(QProfileDto writtenDto, QProfileDto readDto) {
- assertThat(readDto.getOrganizationUuid()).isEqualTo(writtenDto.getOrganizationUuid());
- assertThat(readDto.getName()).isEqualTo(writtenDto.getName());
- assertThat(readDto.getKee()).startsWith(writtenDto.getKee());
- assertThat(readDto.getLanguage()).isEqualTo(writtenDto.getLanguage());
- assertThat(readDto.getId()).isEqualTo(writtenDto.getId());
- assertThat(readDto.getParentKee()).isEqualTo(writtenDto.getParentKee());
- }
-}
package org.sonar.server.qualityprofile;
import java.util.Collections;
-import java.util.List;
+import java.util.Set;
import org.assertj.core.api.AbstractObjectAssert;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
+import org.mockito.ArgumentCaptor;
import org.sonar.api.rule.Severity;
import org.sonar.api.utils.System2;
+import org.sonar.api.utils.internal.AlwaysIncreasingSystem2;
import org.sonar.core.util.SequenceUuidFactory;
+import org.sonar.core.util.Uuids;
+import org.sonar.db.DbSession;
import org.sonar.db.DbTester;
import org.sonar.db.component.ComponentDto;
import org.sonar.db.organization.OrganizationDto;
import org.sonar.db.qualityprofile.ActiveRuleDto;
import org.sonar.db.qualityprofile.ActiveRuleParamDto;
+import org.sonar.db.qualityprofile.OrgQProfileDto;
+import org.sonar.db.qualityprofile.QProfileChangeDto;
import org.sonar.db.qualityprofile.QProfileDto;
+import org.sonar.db.qualityprofile.RulesProfileDto;
import org.sonar.db.rule.RuleDefinitionDto;
import org.sonar.db.rule.RuleParamDto;
+import org.sonar.server.exceptions.BadRequestException;
import org.sonar.server.qualityprofile.index.ActiveRuleIndexer;
import static java.util.Arrays.asList;
import static org.mockito.Mockito.verifyZeroInteractions;
public class QProfileFactoryTest {
+
+ private System2 system2 = new AlwaysIncreasingSystem2();
+
@Rule
public ExpectedException expectedException = ExpectedException.none();
@Rule
- public DbTester db = DbTester.create();
+ public DbTester db = DbTester.create(system2);
+ private DbSession dbSession = db.getSession();
private ActiveRuleIndexer activeRuleIndexer = mock(ActiveRuleIndexer.class);
- private QProfileFactory underTest = new QProfileFactory(db.getDbClient(), new SequenceUuidFactory(), System2.INSTANCE, activeRuleIndexer);
+ private QProfileFactory underTest = new QProfileFactory(db.getDbClient(), new SequenceUuidFactory(), system2, activeRuleIndexer);
private RuleDefinitionDto rule;
private RuleParamDto ruleParam;
@Before
- public void setUp() throws Exception {
+ public void setUp() {
rule = db.rules().insert();
ruleParam = db.rules().insertRuleParam(rule);
}
@Test
- public void deleteByKeys_deletes_profiles_in_db_and_elasticsearch() {
+ public void checkAndCreateCustom() {
+ OrganizationDto organization = db.organizations().insert();
+
+ QProfileDto profile = underTest.checkAndCreateCustom(dbSession, organization, new QProfileName("xoo", "P1"));
+
+ assertThat(profile.getOrganizationUuid()).isEqualTo(organization.getUuid());
+ assertThat(profile.getKee()).isNotEmpty();
+ assertThat(profile.getName()).isEqualTo("P1");
+ assertThat(profile.getLanguage()).isEqualTo("xoo");
+ assertThat(profile.getId()).isNotNull();
+ assertThat(profile.isBuiltIn()).isFalse();
+
+ QProfileDto reloaded = db.getDbClient().qualityProfileDao().selectByNameAndLanguage(dbSession, organization, profile.getName(), profile.getLanguage());
+ assertEqual(profile, reloaded);
+ assertThat(db.getDbClient().qualityProfileDao().selectOrderedByOrganizationUuid(dbSession, organization)).extracting(QProfileDto::getKee).containsExactly(profile.getKee());
+ }
+
+ @Test
+ public void checkAndCreateCustom_throws_BadRequestException_if_name_null() {
+ QProfileName name = new QProfileName("xoo", null);
+ OrganizationDto organization = db.organizations().insert();
+
+ expectBadRequestException("quality_profiles.profile_name_cant_be_blank");
+
+ underTest.checkAndCreateCustom(dbSession, organization, name);
+ }
+
+ @Test
+ public void checkAndCreateCustom_throws_BadRequestException_if_name_empty() {
+ QProfileName name = new QProfileName("xoo", "");
+ OrganizationDto organization = db.organizations().insert();
+
+ expectBadRequestException("quality_profiles.profile_name_cant_be_blank");
+
+ underTest.checkAndCreateCustom(dbSession, organization, name);
+ }
+
+ @Test
+ public void checkAndCreateCustom_throws_BadRequestException_if_already_exists() {
+ QProfileName name = new QProfileName("xoo", "P1");
+ OrganizationDto organization = db.organizations().insert();
+
+ underTest.checkAndCreateCustom(dbSession, organization, name);
+ dbSession.commit();
+
+ expectBadRequestException("Quality profile already exists: {lang=xoo, name=P1}");
+
+ underTest.checkAndCreateCustom(dbSession, organization, name);
+ }
+
+ @Test
+ public void delete_custom_profiles() {
OrganizationDto org = db.organizations().insert();
- QProfileDto profile1 = createRandomProfile(org);
- QProfileDto profile2 = createRandomProfile(org);
- QProfileDto profile3 = createRandomProfile(org);
+ QProfileDto profile1 = createCustomProfile(org);
+ QProfileDto profile2 = createCustomProfile(org);
+ QProfileDto profile3 = createCustomProfile(org);
- List<String> profileKeys = asList(profile1.getKee(), profile2.getKee(), "does_not_exist");
- underTest.deleteByKeys(db.getSession(), profileKeys);
+ underTest.delete(dbSession, asList(profile1, profile2));
- verify(activeRuleIndexer).deleteByProfileKeys(profileKeys);
- assertQualityProfileFromDb(profile1).isNull();
- assertQualityProfileFromDb(profile2).isNull();
- assertQualityProfileFromDb(profile3).isNotNull();
+ verifyCallActiveRuleIndexerDelete(profile1.getKee(), profile2.getKee());
+ assertThatCustomProfileDoesNotExist(profile1);
+ assertThatCustomProfileDoesNotExist(profile2);
+ assertThatCustomProfileExists(profile3);
}
@Test
- public void deleteByKeys_accepts_empty_list_of_keys() {
+ public void delete_removes_custom_profile_marked_as_default() {
OrganizationDto org = db.organizations().insert();
- QProfileDto profile1 = createRandomProfile(org);
+ QProfileDto profile = createCustomProfile(org);
+ db.qualityProfiles().setAsDefault(profile);
- underTest.deleteByKeys(db.getSession(), Collections.emptyList());
+ underTest.delete(dbSession, asList(profile));
- verifyZeroInteractions(activeRuleIndexer);
- assertQualityProfileFromDb(profile1).isNotNull();
+ assertThatCustomProfileDoesNotExist(profile);
+ }
+
+ @Test
+ public void delete_removes_custom_profile_from_project_associations() {
+ OrganizationDto org = db.organizations().insert();
+ QProfileDto profile = createCustomProfile(org);
+ ComponentDto project = db.components().insertPrivateProject(org);
+ db.qualityProfiles().associateWithProject(project, profile);
+
+ underTest.delete(dbSession, asList(profile));
+
+ assertThatCustomProfileDoesNotExist(profile);
+ }
+
+ @Test
+ public void delete_builtin_profile() {
+ RulesProfileDto builtInProfile = createBuiltInProfile();
+ OrganizationDto org = db.organizations().insert();
+ QProfileDto profile = associateBuiltInProfileToOrganization(builtInProfile, org);
+
+ underTest.delete(dbSession, asList(profile));
+
+ verifyNoCallsActiveRuleIndexerDelete();
+
+ // remove only from org_qprofiles
+ assertThat(db.getDbClient().qualityProfileDao().selectOrderedByOrganizationUuid(dbSession, org)).isEmpty();
+
+ assertThatRulesProfileExists(builtInProfile);
}
- private QProfileDto createRandomProfile(OrganizationDto org) {
- QProfileDto profile = db.qualityProfiles().insert(org);
+ @Test
+ public void delete_builtin_profile_associated_to_project() {
+ RulesProfileDto builtInProfile = createBuiltInProfile();
+ OrganizationDto org = db.organizations().insert();
ComponentDto project = db.components().insertPrivateProject(org);
+ QProfileDto profile = associateBuiltInProfileToOrganization(builtInProfile, org);
db.qualityProfiles().associateWithProject(project, profile);
+ assertThat(db.getDbClient().qualityProfileDao().selectAssociatedToProjectAndLanguage(dbSession, project, profile.getLanguage())).isNotNull();
+
+ underTest.delete(dbSession, asList(profile));
+
+ verifyNoCallsActiveRuleIndexerDelete();
+
+ // remove only from org_qprofiles and project_qprofiles
+ assertThat(db.getDbClient().qualityProfileDao().selectOrderedByOrganizationUuid(dbSession, org)).isEmpty();
+ assertThat(db.getDbClient().qualityProfileDao().selectAssociatedToProjectAndLanguage(dbSession, project, profile.getLanguage())).isNull();
+ assertThatRulesProfileExists(builtInProfile);
+ }
+
+ @Test
+ public void delete_builtin_profile_marked_as_default_on_organization() {
+ RulesProfileDto builtInProfile = createBuiltInProfile();
+ OrganizationDto org = db.organizations().insert();
+ QProfileDto profile = associateBuiltInProfileToOrganization(builtInProfile, org);
+ db.qualityProfiles().setAsDefault(profile);
+
+ underTest.delete(dbSession, asList(profile));
+
+ verifyNoCallsActiveRuleIndexerDelete();
+
+ // remove only from org_qprofiles and default_qprofiles
+ assertThat(db.getDbClient().qualityProfileDao().selectOrderedByOrganizationUuid(dbSession, org)).isEmpty();
+ assertThat(db.getDbClient().qualityProfileDao().selectDefaultProfile(dbSession, org, profile.getLanguage())).isNull();
+ assertThatRulesProfileExists(builtInProfile);
+ }
+
+ @Test
+ public void delete_accepts_empty_list_of_keys() {
+ OrganizationDto org = db.organizations().insert();
+ QProfileDto profile = createCustomProfile(org);
+
+ underTest.delete(dbSession, Collections.emptyList());
+
+ verifyZeroInteractions(activeRuleIndexer);
+ assertQualityProfileFromDb(profile).isNotNull();
+ }
+
+ private QProfileDto createCustomProfile(OrganizationDto org) {
+ QProfileDto profile = db.qualityProfiles().insert(org, p -> p.setLanguage("xoo").setIsBuiltIn(false));
+ ActiveRuleDto activeRuleDto = db.qualityProfiles().activateRule(profile, rule);
+
+ ActiveRuleParamDto activeRuleParam = new ActiveRuleParamDto()
+ .setRulesParameterId(ruleParam.getId())
+ .setKey("foo")
+ .setValue("bar");
+ db.getDbClient().activeRuleDao().insertParam(dbSession, activeRuleDto, activeRuleParam);
+
+ db.getDbClient().qProfileChangeDao().insert(dbSession, new QProfileChangeDto()
+ .setChangeType(ActiveRuleChange.Type.ACTIVATED.name())
+ .setRulesProfileUuid(profile.getRulesProfileUuid()));
+ db.commit();
+ return profile;
+ }
+
+ private RulesProfileDto createBuiltInProfile() {
+ RulesProfileDto rulesProfileDto = new RulesProfileDto()
+ .setIsBuiltIn(true)
+ .setKee(Uuids.createFast())
+ .setLanguage("xoo")
+ .setName("Sonar way");
+ db.getDbClient().qualityProfileDao().insert(dbSession, rulesProfileDto);
ActiveRuleDto activeRuleDto = new ActiveRuleDto()
- .setProfileId(profile.getId())
+ .setProfileId(rulesProfileDto.getId())
.setRuleId(rule.getId())
.setSeverity(Severity.BLOCKER);
- db.getDbClient().activeRuleDao().insert(db.getSession(), activeRuleDto);
+ db.getDbClient().activeRuleDao().insert(dbSession, activeRuleDto);
+
ActiveRuleParamDto activeRuleParam = new ActiveRuleParamDto()
.setRulesParameterId(ruleParam.getId())
.setKey("foo")
.setValue("bar");
- db.getDbClient().activeRuleDao().insertParam(db.getSession(), activeRuleDto, activeRuleParam);
- db.getSession().commit();
- return profile;
+ db.getDbClient().activeRuleDao().insertParam(dbSession, activeRuleDto, activeRuleParam);
+
+ db.getDbClient().qProfileChangeDao().insert(dbSession, new QProfileChangeDto()
+ .setChangeType(ActiveRuleChange.Type.ACTIVATED.name())
+ .setRulesProfileUuid(rulesProfileDto.getKee()));
+
+ db.commit();
+ return rulesProfileDto;
+ }
+
+ private QProfileDto associateBuiltInProfileToOrganization(RulesProfileDto rulesProfile, OrganizationDto organization) {
+ OrgQProfileDto orgQProfileDto = new OrgQProfileDto()
+ .setUuid(Uuids.createFast())
+ .setRulesProfileUuid(rulesProfile.getKee())
+ .setOrganizationUuid(organization.getUuid());
+ db.getDbClient().qualityProfileDao().insert(dbSession, orgQProfileDto);
+ db.commit();
+ return QProfileDto.from(orgQProfileDto, rulesProfile);
}
private AbstractObjectAssert<?, QProfileDto> assertQualityProfileFromDb(QProfileDto profile) {
- return assertThat(db.getDbClient().qualityProfileDao().selectByUuid(db.getSession(), profile.getKee()));
+ return assertThat(db.getDbClient().qualityProfileDao().selectByUuid(dbSession, profile.getKee()));
+ }
+
+ private void verifyNoCallsActiveRuleIndexerDelete() {
+ verifyCallActiveRuleIndexerDelete();
+ }
+
+ private void verifyCallActiveRuleIndexerDelete(String... expectedProfileUuids) {
+ Class<Set<QProfileDto>> setClass = (Class<Set<QProfileDto>>) (Class) Set.class;
+ ArgumentCaptor<Set<QProfileDto>> setCaptor = ArgumentCaptor.forClass(setClass);
+ verify(activeRuleIndexer).deleteByProfiles(setCaptor.capture());
+
+ assertThat(setCaptor.getValue())
+ .extracting(QProfileDto::getKee)
+ .containsExactlyInAnyOrder(expectedProfileUuids);
+ }
+
+ private void assertThatRulesProfileExists(RulesProfileDto rulesProfile) {
+ assertThat(db.getDbClient().qualityProfileDao().selectBuiltInRulesProfiles(dbSession))
+ .extracting(RulesProfileDto::getKee)
+ .containsExactly(rulesProfile.getKee());
+ assertThat(db.countRowsOfTable(dbSession, "active_rules")).isGreaterThan(0);
+ assertThat(db.countRowsOfTable(dbSession, "active_rule_parameters")).isGreaterThan(0);
+ assertThat(db.countRowsOfTable(dbSession, "qprofile_changes")).isGreaterThan(0);
+ }
+
+ private void assertThatCustomProfileDoesNotExist(QProfileDto profile) {
+ assertThat(db.countSql(dbSession, "select count(*) from org_qprofiles where uuid = '" + profile.getKee() + "'")).isEqualTo(0);
+ assertThat(db.countSql(dbSession, "select count(*) from project_qprofiles where profile_key = '" + profile.getKee() + "'")).isEqualTo(0);
+ assertThat(db.countSql(dbSession, "select count(*) from default_qprofiles where qprofile_uuid = '" + profile.getKee() + "'")).isEqualTo(0);
+ assertThat(db.countSql(dbSession, "select count(*) from rules_profiles where kee = '" + profile.getRulesProfileUuid() + "'")).isEqualTo(0);
+ assertThat(db.countSql(dbSession, "select count(*) from active_rules where profile_id = " + profile.getId())).isEqualTo(0);
+ assertThat(db.countSql(dbSession, "select count(*) from qprofile_changes where qprofile_key = '" + profile.getRulesProfileUuid() + "'")).isEqualTo(0);
+ // TODO active_rule_parameters
+ }
+
+ private void assertThatCustomProfileExists(QProfileDto profile) {
+ assertThat(db.countSql(dbSession, "select count(*) from org_qprofiles where uuid = '" + profile.getKee() + "'")).isGreaterThan(0);
+ //assertThat(db.countSql(dbSession, "select count(*) from project_qprofiles where profile_key = '" + profile.getKee() + "'")).isGreaterThan(0);
+ //assertThat(db.countSql(dbSession, "select count(*) from default_qprofiles where qprofile_uuid = '" + profile.getKee() + "'")).isGreaterThan(0);
+ assertThat(db.countSql(dbSession, "select count(*) from rules_profiles where kee = '" + profile.getRulesProfileUuid() + "'")).isEqualTo(1);
+ assertThat(db.countSql(dbSession, "select count(*) from active_rules where profile_id = " + profile.getId())).isGreaterThan(0);
+ assertThat(db.countSql(dbSession, "select count(*) from qprofile_changes where qprofile_key = '" + profile.getRulesProfileUuid() + "'")).isGreaterThan(0);
+ // TODO active_rule_parameters
+ }
+
+ private void assertThatCustomProfileIsDefault(OrganizationDto org, QProfileDto profile) {
+ assertThat(db.getDbClient().qualityProfileDao().selectDefaultProfile(dbSession, org, profile.getLanguage())).isEqualTo(profile.getKee());
+ }
+
+ private void assertThatCustomProfileIsAssociatedToProject(OrganizationDto org, QProfileDto profile) {
+ assertThat(db.getDbClient().qualityProfileDao().selectProjectAssociations(dbSession, org, profile, null)).isNotEmpty();
+ }
+
+ private static void assertEqual(QProfileDto p1, QProfileDto p2) {
+ assertThat(p2.getOrganizationUuid()).isEqualTo(p1.getOrganizationUuid());
+ assertThat(p2.getName()).isEqualTo(p1.getName());
+ assertThat(p2.getKee()).startsWith(p1.getKee());
+ assertThat(p2.getLanguage()).isEqualTo(p1.getLanguage());
+ assertThat(p2.getId()).isEqualTo(p1.getId());
+ assertThat(p2.getParentKee()).isEqualTo(p1.getParentKee());
+ }
+
+ private void expectBadRequestException(String message) {
+ expectedException.expect(BadRequestException.class);
+ expectedException.expectMessage(message);
}
}
/**
* Utility class for tests involving quality profiles
*/
+@Deprecated
public class QProfileTesting {
public static final QProfileName XOO_P1_NAME = new QProfileName("xoo", "P1");
*/
@Deprecated
public static QProfileDto newQProfileDto(String organizationUuid, QProfileName name, String key) {
- return QProfileDto.createFor(key).setOrganizationUuid(organizationUuid).setName(name.getName()).setLanguage(name.getLanguage());
+ return new QProfileDto()
+ .setKee(key)
+ .setRulesProfileUuid("rp-" + key)
+ .setOrganizationUuid(organizationUuid)
+ .setName(name.getName())
+ .setLanguage(name.getLanguage());
}
/**
return newQProfileDto(organizationUuid, XOO_P3_NAME, XOO_P3_KEY);
}
- public static QProfileDto newQProfileDto(OrganizationDto organization, QProfileName name, String key) {
- return QProfileDto.createFor(key).setOrganizationUuid(organization.getUuid()).setName(name.getName()).setLanguage(name.getLanguage());
+ public static QProfileDto newQProfileDto(OrganizationDto organization, QProfileName name, String uuid) {
+ return new QProfileDto()
+ .setKee(uuid)
+ .setRulesProfileUuid("rp-" + uuid)
+ .setOrganizationUuid(organization.getUuid())
+ .setName(name.getName())
+ .setLanguage(name.getLanguage());
}
public static QProfileDto newXooP1(OrganizationDto organization) {
import org.sonar.db.qualityprofile.ActiveRuleKey;
import org.sonar.db.qualityprofile.ActiveRuleParamDto;
import org.sonar.db.qualityprofile.DefaultQProfileDto;
-import org.sonar.db.qualityprofile.QualityProfileDao;
import org.sonar.db.qualityprofile.QProfileDto;
+import org.sonar.db.qualityprofile.QualityProfileDao;
import org.sonar.server.es.SearchOptions;
import org.sonar.server.platform.Platform;
import org.sonar.server.rule.index.RuleIndex;
import static com.google.common.collect.Lists.newArrayList;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.guava.api.Assertions.assertThat;
import static org.sonar.server.qualityprofile.QProfileTesting.getDefaultOrganization;
// TODO replace this MediumTest by DbTester and EsTester
// Check Profile in DB
QualityProfileDao qualityProfileDao = dbClient.qualityProfileDao();
- assertThat(qualityProfileDao.selectAll(dbSession, organization)).hasSize(1);
+ assertThat(qualityProfileDao.selectOrderedByOrganizationUuid(dbSession, organization)).hasSize(1);
QProfileDto profile = qualityProfileDao.selectByNameAndLanguage(dbSession, organization, "Basic", "xoo");
assertThat(profile).isNotNull();
assertThat(profile.isBuiltIn()).isTrue();
// Check ActiveRules in DB
ActiveRuleDao activeRuleDao = dbClient.activeRuleDao();
- assertThat(activeRuleDao.selectByProfileKey(dbSession, profile.getKee())).hasSize(2);
+ assertThat(activeRuleDao.selectByProfileUuid(dbSession, profile.getKee())).hasSize(2);
RuleKey ruleKey = RuleKey.of("xoo", "x1");
- ActiveRuleKey activeRuleKey = ActiveRuleKey.of(profile.getKee(), ruleKey);
+ ActiveRuleKey activeRuleKey = ActiveRuleKey.of(profile, ruleKey);
assertThat(activeRuleDao.selectByKey(dbSession, activeRuleKey)).isPresent();
// Check in ES
- assertThat(tester.get(RuleIndex.class).search(new RuleQuery().setActivation(true), new SearchOptions()).getIds()).containsOnly(ruleKey, RuleKey.of("xoo", "x2"));
+ assertThat(tester.get(RuleIndex.class).search(new RuleQuery().setActivation(true).setQProfile(profile), new SearchOptions()).getIds()).containsOnly(ruleKey, RuleKey.of("xoo", "x2"));
tester.get(Platform.class).restart();
// Check ActiveRules
ActiveRuleDto activeRule = activeRuleDao.selectByKey(dbSession, activeRuleKey).get();
- assertThat(activeRule.getKey().qProfile()).isEqualTo(profile.getKee());
- assertThat(activeRule.getKey().ruleKey()).isEqualTo(ruleKey);
+ assertThat(activeRule.getKey().getRuleProfileUuid()).isEqualTo(profile.getRulesProfileUuid());
+ assertThat(activeRule.getKey().getRuleKey()).isEqualTo(ruleKey);
assertThat(activeRule.getSeverityString()).isEqualTo(Severity.CRITICAL);
// Check in ES
- assertThat(tester.get(RuleIndex.class).search(new RuleQuery().setActivation(true), new SearchOptions()).getIds()).containsOnly(ruleKey, RuleKey.of("xoo", "x2"));
+ assertThat(tester.get(RuleIndex.class).search(new RuleQuery().setActivation(true).setQProfile(profile), new SearchOptions()).getIds()).containsOnly(ruleKey, RuleKey.of("xoo", "x2"));
// TODO
// Check ActiveRuleParameters in DB
// Check Profile in DB
QualityProfileDao qualityProfileDao = dbClient.qualityProfileDao();
- assertThat(qualityProfileDao.selectAll(dbSession, organization)).hasSize(1);
+ assertThat(qualityProfileDao.selectOrderedByOrganizationUuid(dbSession, organization)).hasSize(1);
QProfileDto profile = qualityProfileDao.selectByNameAndLanguage(dbSession, organization, "Basic", "xoo");
assertThat(profile).isNotNull();
assertThat(profile.isBuiltIn()).isTrue();
// Check ActiveRules in DB
ActiveRuleDao activeRuleDao = dbClient.activeRuleDao();
- assertThat(activeRuleDao.selectByProfileKey(dbSession, profile.getKee())).hasSize(2);
+ assertThat(activeRuleDao.selectByProfileUuid(dbSession, profile.getKee())).hasSize(2);
RuleKey ruleKey = RuleKey.of("xoo", "x1");
- ActiveRuleDto activeRule = activeRuleDao.selectByKey(dbSession, ActiveRuleKey.of(profile.getKee(), ruleKey)).get();
- assertThat(activeRule.getKey().qProfile()).isEqualTo(profile.getKee());
- assertThat(activeRule.getKey().ruleKey()).isEqualTo(ruleKey);
+ ActiveRuleDto activeRule = activeRuleDao.selectByKey(dbSession, ActiveRuleKey.of(profile, ruleKey)).get();
+ assertThat(activeRule.getKey().getRuleProfileUuid()).isEqualTo(profile.getRulesProfileUuid());
+ assertThat(activeRule.getKey().getRuleKey()).isEqualTo(ruleKey);
assertThat(activeRule.getSeverityString()).isEqualTo(Severity.CRITICAL);
// Check ActiveRuleParameters in DB
// Check Profile in DB
QualityProfileDao qualityProfileDao = dbClient().qualityProfileDao();
- assertThat(qualityProfileDao.selectAll(dbSession, organization)).hasSize(0);
+ assertThat(qualityProfileDao.selectOrderedByOrganizationUuid(dbSession, organization)).hasSize(0);
}
@Test
import java.util.ArrayList;
import java.util.List;
-import java.util.Objects;
+import org.apache.commons.lang.RandomStringUtils;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.sonar.db.DbTester;
import org.sonar.db.organization.OrganizationDto;
import org.sonar.db.qualityprofile.QProfileDto;
+import org.sonar.db.qualityprofile.RulesProfileDto;
import org.sonar.server.language.LanguageTesting;
-import org.sonar.server.qualityprofile.index.ActiveRuleIndexer;
import org.sonar.server.tester.UserSessionRule;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
public class RegisterQualityProfilesTest {
- private static final Language FOO_LANGUAGE = LanguageTesting.newLanguage("foo", "foo", "foo");
- private static final Language BAR_LANGUAGE = LanguageTesting.newLanguage("bar", "bar", "bar");
+ private static final Language FOO_LANGUAGE = LanguageTesting.newLanguage("foo");
+ private static final Language BAR_LANGUAGE = LanguageTesting.newLanguage("bar");
@Rule
- public DbTester dbTester = DbTester.create(new AlwaysIncreasingSystem2());
+ public DbTester db = DbTester.create(new AlwaysIncreasingSystem2());
@Rule
public UserSessionRule userSessionRule = UserSessionRule.standalone();
@Rule
@Rule
public LogTester logTester = new LogTester();
- private DbClient dbClient = dbTester.getDbClient();
- private ActiveRuleIndexer mockedActiveRuleIndexer = mock(ActiveRuleIndexer.class);
- private DummyBuiltInQProfileInsert builtInQProfileCreation = new DummyBuiltInQProfileInsert();
+ private DbClient dbClient = db.getDbClient();
+ private DummyBuiltInQProfileInsert insert = new DummyBuiltInQProfileInsert();
private RegisterQualityProfiles underTest = new RegisterQualityProfiles(
builtInQProfileRepositoryRule,
dbClient,
- builtInQProfileCreation,
- mockedActiveRuleIndexer);
+ insert);
@Test
public void start_fails_if_BuiltInQProfileRepository_has_not_been_initialized() {
}
@Test
- public void create_built_in_profile_on_organizations_that_dont_have_it() {
- OrganizationDto organization1 = dbTester.organizations().insert();
- OrganizationDto organization2 = dbTester.organizations().insert();
- BuiltInQProfile builtInQProfile = builtInQProfileRepositoryRule.add(FOO_LANGUAGE, "foo1");
+ public void persist_built_in_profiles_that_are_not_persisted_yet() {
+ BuiltInQProfile builtInQProfile = builtInQProfileRepositoryRule.add(FOO_LANGUAGE, "Sonar way");
builtInQProfileRepositoryRule.initialize();
underTest.start();
- assertThat(builtInQProfileCreation.getCallLogs())
- .containsExactly(
- callLog(builtInQProfile, dbTester.getDefaultOrganization()),
- callLog(builtInQProfile, organization1),
- callLog(builtInQProfile, organization2));
+ assertThat(insert.callLogs)
+ .containsExactly(builtInQProfile);
}
@Test
- public void start_creates_different_qps_and_their_loaded_templates_if_several_profile_has_same_name_for_different_languages() {
+ public void dont_persist_built_in_profiles_that_are_already_persisted() {
String name = "doh";
- BuiltInQProfile builtInQProfile1 = builtInQProfileRepositoryRule.add(FOO_LANGUAGE, name, true);
- BuiltInQProfile builtInQProfile2 = builtInQProfileRepositoryRule.add(BAR_LANGUAGE, name, true);
+ BuiltInQProfile persistedBuiltIn = builtInQProfileRepositoryRule.add(FOO_LANGUAGE, name, true);
+ BuiltInQProfile nonPersistedBuiltIn = builtInQProfileRepositoryRule.add(BAR_LANGUAGE, name, true);
builtInQProfileRepositoryRule.initialize();
+ insertRulesProfile(persistedBuiltIn);
underTest.start();
- assertThat(builtInQProfileCreation.getCallLogs())
- .containsExactly(callLog(builtInQProfile2, dbTester.getDefaultOrganization()), callLog(builtInQProfile1, dbTester.getDefaultOrganization()));
+ assertThat(insert.callLogs)
+ .containsExactly(nonPersistedBuiltIn);
}
@Test
- public void rename_custom_outdated_profiles_if_same_name_than_builtin_profile() {
- OrganizationDto org1 = dbTester.organizations().insert(org -> org.setKey("org1"));
- OrganizationDto org2 = dbTester.organizations().insert(org -> org.setKey("org2"));
-
- QProfileDto outdatedProfileInOrg1 = dbTester.qualityProfiles().insert(org1, p -> p.setIsBuiltIn(false).setLanguage(FOO_LANGUAGE.getKey()).setName("Sonar way"));
- QProfileDto outdatedProfileInOrg2 = dbTester.qualityProfiles().insert(org2, p -> p.setIsBuiltIn(false).setLanguage(FOO_LANGUAGE.getKey()).setName("Sonar way"));
+ public void rename_custom_outdated_profiles_if_same_name_than_built_in_profile() {
+ OrganizationDto org1 = db.organizations().insert(org -> org.setKey("org1"));
+ OrganizationDto org2 = db.organizations().insert(org -> org.setKey("org2"));
+
+ QProfileDto outdatedProfileInOrg1 = db.qualityProfiles().insert(org1, p -> p.setIsBuiltIn(false)
+ .setLanguage(FOO_LANGUAGE.getKey()).setName("Sonar way"));
+ QProfileDto outdatedProfileInOrg2 = db.qualityProfiles().insert(org2, p -> p.setIsBuiltIn(false)
+ .setLanguage(FOO_LANGUAGE.getKey()).setName("Sonar way"));
builtInQProfileRepositoryRule.add(FOO_LANGUAGE, "Sonar way", false);
builtInQProfileRepositoryRule.initialize();
underTest.start();
- assertThat(dbTester.qualityProfiles().selectByUuid(outdatedProfileInOrg1.getKee()).get().getName()).isEqualTo("Sonar way (outdated copy)");
- assertThat(dbTester.qualityProfiles().selectByUuid(outdatedProfileInOrg2.getKee()).get().getName()).isEqualTo("Sonar way (outdated copy)");
+ assertThat(selectPersistedName(outdatedProfileInOrg1)).isEqualTo("Sonar way (outdated copy)");
+ assertThat(selectPersistedName(outdatedProfileInOrg2)).isEqualTo("Sonar way (outdated copy)");
assertThat(logTester.logs(LoggerLevel.INFO)).contains("Rename Quality profiles [foo/Sonar way] to [Sonar way (outdated copy)] in 2Â organizations");
}
- private class DummyBuiltInQProfileInsert implements BuiltInQProfileInsert {
- private final List<CallLog> callLogs = new ArrayList<>();
-
- @Override
- public void create(DbSession session, DbSession batchSession, BuiltInQProfile qualityProfile, OrganizationDto organization) {
- callLogs.add(callLog(qualityProfile, organization));
- }
-
- List<CallLog> getCallLogs() {
- return callLogs;
- }
+ private String selectPersistedName(QProfileDto profile) {
+ return db.qualityProfiles().selectByUuid(profile.getKee()).get().getName();
}
- private static final class CallLog {
- private final BuiltInQProfile builtInQProfile;
- private final OrganizationDto organization;
-
- private CallLog(BuiltInQProfile builtInQProfile, OrganizationDto organization) {
- this.builtInQProfile = builtInQProfile;
- this.organization = organization;
- }
-
- @Override
- public boolean equals(Object o) {
- if (this == o) {
- return true;
- }
- if (o == null || getClass() != o.getClass()) {
- return false;
- }
- CallLog callLog = (CallLog) o;
- return builtInQProfile == callLog.builtInQProfile &&
- organization.getUuid().equals(callLog.organization.getUuid());
- }
+ private void insertRulesProfile(BuiltInQProfile builtIn) {
+ RulesProfileDto dto = new RulesProfileDto()
+ .setIsBuiltIn(true)
+ .setKee(RandomStringUtils.randomAlphabetic(40))
+ .setLanguage(builtIn.getLanguage())
+ .setName(builtIn.getName());
+ dbClient.qualityProfileDao().insert(db.getSession(), dto);
+ db.commit();
+ }
- @Override
- public int hashCode() {
- return Objects.hash(builtInQProfile, organization);
- }
+ private static class DummyBuiltInQProfileInsert implements BuiltInQProfileInsert {
+ private final List<BuiltInQProfile> callLogs = new ArrayList<>();
@Override
- public String toString() {
- return "CallLog{" +
- "qp=" + builtInQProfile.getLanguage() + '-' + builtInQProfile.getName() + '-' + builtInQProfile.isDefault() +
- ", org=" + organization.getKey() +
- '}';
+ public void create(DbSession dbSession, DbSession batchDbSession, BuiltInQProfile builtIn) {
+ callLogs.add(builtIn);
}
}
-
- private static CallLog callLog(BuiltInQProfile builtInQProfile, OrganizationDto organizationDto) {
- return new CallLog(builtInQProfile, organizationDto);
- }
}
*/
package org.sonar.server.qualityprofile;
-import com.google.common.collect.ImmutableMap;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
-import javax.annotation.Nullable;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.ClassRule;
-import org.junit.Rule;
-import org.junit.Test;
-import org.sonar.api.rule.RuleKey;
-import org.sonar.api.rule.RuleStatus;
-import org.sonar.api.server.rule.RuleParamType;
-import org.sonar.db.DbClient;
-import org.sonar.db.DbSession;
-import org.sonar.db.organization.OrganizationDto;
-import org.sonar.db.qualityprofile.ActiveRuleDto;
-import org.sonar.db.qualityprofile.ActiveRuleKey;
-import org.sonar.db.qualityprofile.ActiveRuleParamDto;
-import org.sonar.db.qualityprofile.QProfileDto;
-import org.sonar.db.rule.RuleDefinitionDto;
-import org.sonar.db.rule.RuleDto;
-import org.sonar.db.rule.RuleParamDto;
-import org.sonar.server.es.SearchOptions;
-import org.sonar.server.exceptions.BadRequestException;
-import org.sonar.server.organization.DefaultOrganizationProvider;
-import org.sonar.server.qualityprofile.index.ActiveRuleIndexer;
-import org.sonar.server.rule.index.RuleIndex;
-import org.sonar.server.rule.index.RuleIndexer;
-import org.sonar.server.rule.index.RuleQuery;
-import org.sonar.server.tester.ServerTester;
-import org.sonar.server.tester.UserSessionRule;
-
-import static com.google.common.collect.Lists.newArrayList;
-import static java.util.Arrays.asList;
-import static java.util.Collections.singleton;
-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 TEMPLATE_RULE_KEY = RuleKey.of("xoo", "template1");
- static final RuleKey CUSTOM_RULE_KEY = RuleKey.of("xoo", "custom1");
-
- @ClassRule
- public static ServerTester tester = new ServerTester().withEsIndexes();
-
- @Rule
- public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
-
- DbClient db;
- DbSession dbSession;
-
- RuleActivator ruleActivator;
-
- RuleIndexer ruleIndexer;
-
- ActiveRuleIndexer activeRuleIndexer;
-
- QProfileDto profileDto;
- private OrganizationDto organization;
-
- @Before
- public void before() {
- tester.clearDbAndIndexes();
- db = tester.get(DbClient.class);
- dbSession = db.openSession(false);
- ruleActivator = tester.get(RuleActivator.class);
- activeRuleIndexer = tester.get(ActiveRuleIndexer.class);
- ruleIndexer = tester.get(RuleIndexer.class);
- String defaultOrganizationUuid = tester.get(DefaultOrganizationProvider.class).get().getUuid();
- organization = db.organizationDao().selectByUuid(dbSession, defaultOrganizationUuid).orElseThrow(() -> new IllegalStateException(String.format("Cannot find default organization '%s'", defaultOrganizationUuid)));
-
- // create pre-defined rules
- RuleDto javaRule = newDto(RuleKey.of("squid", "j1"))
- .setSeverity("MAJOR").setLanguage("java");
- RuleDto xooRule1 = newXooX1().setSeverity("MINOR");
- RuleDto xooRule2 = newXooX2().setSeverity("INFO");
- RuleDto xooTemplateRule1 = newTemplateRule(TEMPLATE_RULE_KEY)
- .setSeverity("MINOR").setLanguage("xoo");
-
- // store pre-defined rules in database
- asList(javaRule, xooRule1, xooRule2, xooTemplateRule1).stream()
- .map(RuleDto::getDefinition)
- .forEach(definition -> db.ruleDao().insert(dbSession, definition));
- db.ruleDao().insertRuleParam(dbSession, xooRule1.getDefinition(), RuleParamDto.createFor(xooRule1.getDefinition())
- .setName("max").setDefaultValue("10").setType(RuleParamType.INTEGER.type()));
- db.ruleDao().insertRuleParam(dbSession, xooRule1.getDefinition(), RuleParamDto.createFor(xooRule1.getDefinition())
- .setName("min").setType(RuleParamType.INTEGER.type()));
- db.ruleDao().insertRuleParam(dbSession, xooTemplateRule1.getDefinition(), RuleParamDto.createFor(xooTemplateRule1.getDefinition())
- .setName("format").setType(RuleParamType.STRING.type()));
-
- // create custom rule
- RuleDto xooCustomRule1 = newCustomRule(xooTemplateRule1).setRuleKey(CUSTOM_RULE_KEY.rule())
- .setSeverity("MINOR").setLanguage("xoo");
-
- // store custom rule in database
- db.ruleDao().insert(dbSession, xooCustomRule1.getDefinition());
- db.ruleDao().insertRuleParam(dbSession, xooCustomRule1.getDefinition(), RuleParamDto.createFor(xooTemplateRule1.getDefinition())
- .setName("format").setDefaultValue("txt").setType(RuleParamType.STRING.type()));
-
- // create pre-defined profile P1
- profileDto = QProfileTesting.newXooP1(organization);
- db.qualityProfileDao().insert(dbSession, profileDto);
-
- // index all rules
- dbSession.commit();
- ruleIndexer.indexRuleDefinitions(asList(javaRule, xooRule1, xooRule2, xooTemplateRule1, xooCustomRule1).stream().map(RuleDto::getKey).collect(Collectors.toList()));
- }
-
- @After
- public void after() {
- dbSession.close();
- }
-
- @Test
- public void activate() {
- RuleActivation activation = new RuleActivation(XOO_X1);
- activation.setSeverity(BLOCKER);
- activation.setParameter("max", "7");
- activation.setParameter("min", "3");
- List<ActiveRuleChange> changes = ruleActivator.activate(dbSession, activation, XOO_P1_KEY);
- dbSession.commit();
- dbSession.clearCache();
-
- assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(1);
- 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);
- }
-
- @Test
- public void automatic_activation_does_not_update_intended_column() {
- RuleActivation activation = new RuleActivation(XOO_X1);
- activation.setSeverity(BLOCKER);
- activation.setParameter("max", "7");
- activation.setParameter("min", "3");
- List<ActiveRuleChange> changes = ruleActivator.activate(dbSession, activation, XOO_P1_KEY);
- dbSession.commit();
- dbSession.clearCache();
- userSessionRule.anonymous();
-
- assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(1);
- 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);
- assertProfileHasBeenUpdatedAutomatically(XOO_P1_KEY);
- }
-
- @Test
- public void activate_with_profile_dto() {
- RuleActivation activation = new RuleActivation(XOO_X1);
- activation.setSeverity(BLOCKER);
- activation.setParameter("max", "7");
- activation.setParameter("min", "3");
- userSessionRule.logIn().setRoot();
- List<ActiveRuleChange> changes = ruleActivator.activate(dbSession, activation, profileDto);
- dbSession.commit();
- dbSession.clearCache();
-
- assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(1);
- 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);
- assertProfileHasBeenUpdatedManually(profileDto.getKee());
- }
-
- @Test
- public void activate_with_default_severity_and_parameter() {
- activate(new RuleActivation(XOO_X1), XOO_P1_KEY);
-
- assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(1);
- verifyHasActiveRuleInDb(ActiveRuleKey.of(XOO_P1_KEY, XOO_X1), MINOR, null,
- ImmutableMap.of("max", "10"));
- }
-
- /**
- * SONAR-5841
- */
- @Test
- public void activate_with_empty_parameter_having_no_default_value() {
- activate(new RuleActivation(XOO_X1)
- .setParameter("min", ""),
- XOO_P1_KEY);
-
- assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(1);
- verifyHasActiveRuleInDb(ActiveRuleKey.of(XOO_P1_KEY, XOO_X1), MINOR, null,
- // Max should be set to default value, min has no value it should be ignored
- ImmutableMap.of("max", "10"));
- }
-
- /**
- * SONAR-5841
- */
- @Test
- public void activate_with_empty_parameters() {
- 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
- verifyHasActiveRuleInDb(ActiveRuleKey.of(XOO_P1_KEY, XOO_X1), MINOR, null,
- ImmutableMap.of("max", "10"));
- }
-
- /**
- * SONAR-5840
- */
- @Test
- public void activate_rule_with_negative_integer_value_on_parameter_having_no_default_value() {
- 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
- 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(XOO_X1);
- activation.setParameter("xxx", "yyy");
- activate(activation, XOO_P1_KEY);
-
- assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(1);
- 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(XOO_X1);
- activation.setSeverity(BLOCKER);
- activate(activation, XOO_P1_KEY);
-
- // update
- RuleActivation update = new RuleActivation(XOO_X1);
- update.setSeverity(CRITICAL);
- update.setParameter("max", "42");
- List<ActiveRuleChange> changes = activate(update, XOO_P1_KEY);
-
- assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(1);
- 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);
- }
-
- @Test
- public void update_activation_with_parameter_without_default_value() {
- // initial activation -> param "max" has a default value
- RuleActivation activation = new RuleActivation(XOO_X1);
- activation.setSeverity(BLOCKER);
- activate(activation, XOO_P1_KEY);
- 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(XOO_X1);
- update.setParameter("min", "3");
- List<ActiveRuleChange> changes = activate(update, XOO_P1_KEY);
- assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(1);
- 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);
- }
-
- @Test
- public void update_activation_remove_parameter_value_having_default_value() {
- // initial activation
- activate(new RuleActivation(XOO_X1).setSeverity(BLOCKER).setParameter("max", "20"), XOO_P1_KEY);
-
- // update
- activate(new RuleActivation(XOO_X1).setParameter("max", null), XOO_P1_KEY);
-
- verifyHasActiveRuleInDb(ActiveRuleKey.of(XOO_P1_KEY, XOO_X1), BLOCKER, null, ImmutableMap.of("max", "10"));
- }
-
- @Test
- public void update_activation_remove_parameter_value_without_default_value() {
- // initial activation -> param "min" has a no default value
- activate(new RuleActivation(XOO_X1).setSeverity(BLOCKER).setParameter("min", "5"), XOO_P1_KEY);
-
- // update param "min" with empty value
- activate(new RuleActivation(XOO_X1).setParameter("min", null), XOO_P1_KEY);
-
- verifyHasActiveRuleInDb(ActiveRuleKey.of(XOO_P1_KEY, XOO_X1), BLOCKER, null, ImmutableMap.of("max", "10"));
- }
-
- @Test
- public void update_activation_but_new_parameter() {
- // initial activation
- 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.activeRuleDao().selectParamByKeyAndName(activeRuleKey, "max", dbSession)).isNotNull();
- db.activeRuleDao().deleteParamByKeyAndName(dbSession, activeRuleKey, "max");
- dbSession.commit();
- assertThat(db.activeRuleDao().selectParamByKeyAndName(activeRuleKey, "max", dbSession)).isNull();
- dbSession.clearCache();
-
- // update
- 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);
- verifyHasActiveRuleInDb(activeRuleKey, CRITICAL, null, ImmutableMap.of("max", "42"));
- }
-
- @Test
- public void ignore_activation_without_changes() {
- // initial activation
- 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(XOO_X1);
- update.setSeverity(BLOCKER);
- List<ActiveRuleChange> changes = activate(update, XOO_P1_KEY);
- assertThat(changes).isEmpty();
- }
-
- @Test
- public void do_not_change_severity_and_params_if_unset_and_already_activated() {
- // initial activation
- 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(XOO_X1);
- activate(update, XOO_P1_KEY);
-
- assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(1);
- 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, 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(XOO_X1).setReset(true);
- activate(update, XOO_P1_KEY);
- assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(1);
- verifyHasActiveRuleInDb(activeRuleKey, MINOR, null,
- // only default values
- ImmutableMap.of("max", "10"));
- }
-
- @Test
- public void ignore_parameters_when_activating_custom_rule() {
- // initial activation
- ActiveRuleKey activeRuleKey = ActiveRuleKey.of(XOO_P1_KEY, CUSTOM_RULE_KEY);
- RuleActivation activation = new RuleActivation(CUSTOM_RULE_KEY);
- activate(activation, XOO_P1_KEY);
-
- // update
- RuleActivation update = new RuleActivation(CUSTOM_RULE_KEY)
- .setParameter("format", "xls");
- activate(update, XOO_P1_KEY);
-
- assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(1);
- verifyHasActiveRuleInDb(activeRuleKey, MINOR, null, ImmutableMap.of("format", "txt"));
- }
-
- @Test
- public void fail_to_activate_if_template() {
- RuleActivation activation = new RuleActivation(TEMPLATE_RULE_KEY);
-
- try {
- activate(activation, XOO_P1_KEY);
- fail();
- } catch (BadRequestException e) {
- assertThat(e).hasMessage("Rule template can't be activated on a Quality profile: xoo:template1");
- verifyZeroActiveRules(XOO_P1_KEY);
- }
- }
-
- @Test
- public void fail_to_activate_if_different_languages() {
- // profile and rule have different languages
- RuleActivation activation = new RuleActivation(RuleKey.of("squid", "j1"));
-
- try {
- activate(activation, XOO_P1_KEY);
- fail();
- } catch (BadRequestException e) {
- assertThat(e).hasMessage("Rule squid:j1 and profile XOO_P1 have different languages");
- verifyZeroActiveRules(XOO_P1_KEY);
- }
- }
-
- @Test
- public void fail_to_activate_if_unknown_rule() {
- // profile and rule have different languages
- RuleActivation activation = new RuleActivation(RuleKey.of("xoo", "x3"));
-
- try {
- activate(activation, XOO_P1_KEY);
- fail();
- } catch (BadRequestException e) {
- assertThat(e).hasMessage("Rule not found: xoo:x3");
- verifyZeroActiveRules(XOO_P1_KEY);
- }
- }
-
- @Test
- public void fail_to_activate_if_rule_with_removed_status() {
- RuleDefinitionDto ruleDto = db.ruleDao().selectOrFailDefinitionByKey(dbSession, XOO_X1);
- ruleDto.setStatus(RuleStatus.REMOVED);
- db.ruleDao().update(dbSession, ruleDto);
- dbSession.commit();
- dbSession.clearCache();
-
- RuleActivation activation = new RuleActivation(XOO_X1);
-
- try {
- activate(activation, XOO_P1_KEY);
- fail();
- } catch (BadRequestException e) {
- assertThat(e).hasMessage("Rule was removed: xoo:x1");
- verifyZeroActiveRules(XOO_P1_KEY);
- }
- }
-
- @Test
- public void fail_to_activate_if_unknown_profile() {
- try {
- activate(new RuleActivation(XOO_X1), "unknown");
- fail();
- } catch (BadRequestException e) {
- assertThat(e).hasMessage("Quality profile not found: unknown");
- }
- }
-
- @Test
- public void fail_to_activate_if_invalid_parameter() {
- RuleActivation activation = new RuleActivation(XOO_X1);
- activation.setParameter("max", "foo");
-
- try {
- activate(activation, XOO_P1_KEY);
- fail();
- } catch (BadRequestException e) {
- assertThat(e.getMessage()).isEqualTo("Value 'foo' must be an integer.");
- verifyZeroActiveRules(XOO_P1_KEY);
- }
- }
-
- @Test
- public void deactivate() {
- // activation
- RuleActivation activation = new RuleActivation(XOO_X1);
- activation.setSeverity(BLOCKER);
- activation.setParameter("max", "7");
- userSessionRule.logIn();
- activate(activation, XOO_P1_KEY);
-
- // deactivation
- ruleActivator.deactivateAndUpdateIndex(dbSession, ActiveRuleKey.of(XOO_P1_KEY, XOO_X1));
-
- verifyZeroActiveRules(XOO_P1_KEY);
- assertProfileHasBeenUpdatedManually(XOO_P1_KEY);
- }
-
- @Test
- public void ignore_deactivation_if_rule_not_activated() {
- // deactivation
- ActiveRuleKey key = ActiveRuleKey.of(XOO_P1_KEY, XOO_X1);
- ruleActivator.deactivateAndUpdateIndex(dbSession, key);
-
- verifyZeroActiveRules(XOO_P1_KEY);
- }
-
- @Test
- public void deactivation_fails_if_rule_not_found() {
- ActiveRuleKey key = ActiveRuleKey.of(XOO_P1_KEY, RuleKey.of("xoo", "x3"));
- try {
- ruleActivator.deactivateAndUpdateIndex(dbSession, key);
- fail();
- } catch (BadRequestException e) {
- assertThat(e).hasMessage("Rule not found: xoo:x3");
- verifyZeroActiveRules(XOO_P1_KEY);
- }
- }
-
- @Test
- public void deactivation_fails_if_profile_not_found() {
- ActiveRuleKey key = ActiveRuleKey.of("unknown", XOO_X1);
- try {
- ruleActivator.deactivateAndUpdateIndex(dbSession, key);
- fail();
- } catch (BadRequestException e) {
- assertThat(e).hasMessage("Quality profile not found: unknown");
- }
- }
-
- @Test
- public void allow_to_deactivate_removed_rule() {
- // activation
- RuleActivation activation = new RuleActivation(XOO_X1);
- activate(activation, XOO_P1_KEY);
-
- // set rule as removed
- RuleDefinitionDto rule = db.ruleDao().selectOrFailDefinitionByKey(dbSession, XOO_X1);
- rule.setStatus(RuleStatus.REMOVED);
- db.ruleDao().update(dbSession, rule);
- dbSession.commit();
- dbSession.clearCache();
-
- // deactivation
- ruleActivator.deactivateAndUpdateIndex(dbSession, ActiveRuleKey.of(XOO_P1_KEY, XOO_X1));
-
- verifyZeroActiveRules(XOO_P1_KEY);
- }
-
- // INHERITANCE OF PROFILES
- @Test
- public void activate_on_child_profile_but_not_on_parent() {
- createChildProfiles();
-
- // activate on child profile, but not on root
- RuleActivation activation = new RuleActivation(XOO_X1);
- activation.setSeverity(BLOCKER);
- activation.setParameter("max", "7");
- activate(activation, XOO_P2_KEY);
-
- verifyZeroActiveRules(XOO_P1_KEY);
- 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(XOO_X1);
- activation.setSeverity(MINOR);
- activation.setParameter("max", "77");
- activate(activation, XOO_P2_KEY);
-
- verifyZeroActiveRules(XOO_P1_KEY);
- 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
- public void propagate_activation_on_child_profiles() {
- createChildProfiles();
-
- // activate on root profile
- RuleActivation activation = new RuleActivation(XOO_X1);
- activation.setSeverity(BLOCKER);
- activation.setParameter("max", "7");
- List<ActiveRuleChange> changes = activate(activation, XOO_P1_KEY);
-
- assertThat(changes).hasSize(3);
- 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
- public void propagate_activation_update_on_child_profiles() {
- createChildProfiles();
- userSessionRule.logIn();
-
- // activate on root profile
- RuleActivation activation = new RuleActivation(XOO_X1);
- activation.setSeverity(BLOCKER);
- activation.setParameter("max", "7");
- activate(activation, XOO_P1_KEY);
- 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(XOO_X1);
- activation.setSeverity(INFO);
- activation.setParameter("max", "8");
- activate(activation, XOO_P1_KEY);
-
- 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(XOO_X1);
- activation.setSeverity(MINOR);
- activation.setParameter("max", "9");
- activate(activation, XOO_P2_KEY);
-
- 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(XOO_X1);
- activation.setSeverity(BLOCKER);
- activation.setParameter("max", "10");
- activate(activation, XOO_P3_KEY);
-
- 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"));
-
- assertProfileHasBeenUpdatedManually(XOO_P1_KEY);
- assertProfileHasBeenUpdatedManually(XOO_P2_KEY);
- assertProfileHasBeenUpdatedManually(XOO_P3_KEY);
- }
-
- @Test
- public void do_not_propagate_activation_update_on_child_overrides() {
- createChildProfiles();
-
- // activate on root profile P1
- RuleActivation activation = new RuleActivation(XOO_X1);
- activation.setSeverity(INFO);
- activation.setParameter("max", "7");
- activate(activation, XOO_P1_KEY);
- 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(XOO_X1);
- activation.setSeverity(BLOCKER);
- activation.setParameter("max", "8");
- activate(activation, XOO_P2_KEY);
- 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(XOO_X1);
- activation.setSeverity(CRITICAL);
- activation.setParameter("max", "9");
- activate(activation, XOO_P1_KEY);
- 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(XOO_X1).setReset(true);
- activate(activation, XOO_P1_KEY);
-
- 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
- public void active_on_parent_a_rule_already_activated_on_child() {
- createChildProfiles();
-
- // activate on child profile
- RuleActivation activation = new RuleActivation(XOO_X1);
- activation.setSeverity(INFO);
- activation.setParameter("max", "7");
- activate(activation, XOO_P2_KEY);
- verifyZeroActiveRules(XOO_P1_KEY);
- 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(XOO_X1);
- activation.setSeverity(MAJOR);
- activation.setParameter("max", "8");
- activate(activation, XOO_P1_KEY);
- 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
- public void do_not_override_on_child_if_same_values() {
- createChildProfiles();
-
- // activate on root profile
- RuleActivation activation = new RuleActivation(XOO_X1);
- activation.setSeverity(INFO);
- activation.setParameter("max", "7");
- activate(activation, XOO_P1_KEY);
- 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(XOO_X1);
- activation.setSeverity(INFO);
- activation.setParameter("max", "7");
- activate(activation, XOO_P2_KEY);
- 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
- public void propagate_deactivation_on_child_profiles() {
- createChildProfiles();
-
- // activate on root profile
- RuleActivation activation = new RuleActivation(XOO_X1);
- activation.setSeverity(BLOCKER);
- activation.setParameter("max", "7");
- activate(activation, XOO_P1_KEY);
- 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.deactivateAndUpdateIndex(dbSession, ActiveRuleKey.of(XOO_P1_KEY, XOO_X1));
-
- verifyZeroActiveRules(XOO_P1_KEY);
- verifyZeroActiveRules(XOO_P2_KEY);
- verifyZeroActiveRules(XOO_P3_KEY);
- }
-
- @Test
- public void propagate_deactivation_even_on_child_overrides() {
- createChildProfiles();
-
- // activate on root profile
- RuleActivation activation = new RuleActivation(XOO_X1);
- activation.setSeverity(INFO);
- activation.setParameter("max", "7");
- activate(activation, XOO_P1_KEY);
- 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(XOO_X1);
- activation.setSeverity(BLOCKER);
- activation.setParameter("max", "8");
- activate(activation, XOO_P2_KEY);
- 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.deactivateAndUpdateIndex(dbSession, ActiveRuleKey.of(XOO_P1_KEY, XOO_X1));
- dbSession.clearCache();
- verifyZeroActiveRules(XOO_P1_KEY);
- verifyZeroActiveRules(XOO_P2_KEY);
- verifyZeroActiveRules(XOO_P3_KEY);
- }
-
- @Test
- public void do_not_deactivate_inherited_or_overridden_rule() {
- createChildProfiles();
-
- // activate on root profile
- RuleActivation activation = new RuleActivation(XOO_X1);
- activation.setSeverity(BLOCKER);
- activation.setParameter("max", "7");
- activate(activation, XOO_P1_KEY);
- 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.deactivateAndUpdateIndex(dbSession, ActiveRuleKey.of(XOO_P2_KEY, XOO_X1));
- fail();
- } catch (BadRequestException e) {
- assertThat(e).hasMessage("Cannot deactivate inherited rule 'xoo:x1'");
- }
- }
-
- @Test
- public void reset_child_profile() {
- createChildProfiles();
-
- // activate on root profile
- RuleActivation activation = new RuleActivation(XOO_X1);
- activation.setSeverity(BLOCKER);
- activation.setParameter("max", "7");
- activate(activation, XOO_P1_KEY);
- 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(XOO_X1);
- activation.setSeverity(INFO);
- activation.setParameter("max", "10");
- activate(activation, XOO_P2_KEY);
- 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(XOO_X1).setReset(true);
- activate(activation, XOO_P2_KEY);
- 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
- public void reset_is_not_propagated_to_child_overrides() {
- createChildProfiles();
-
- // activate on root profile
- RuleActivation activation = new RuleActivation(XOO_X1);
- activation.setSeverity(BLOCKER);
- activation.setParameter("max", "7");
- activate(activation, XOO_P1_KEY);
- 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(XOO_X1);
- activation.setSeverity(INFO);
- activation.setParameter("max", "10");
- activate(activation, XOO_P2_KEY);
- 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(XOO_X1);
- activation.setSeverity(MINOR);
- activation.setParameter("max", "20");
- activate(activation, XOO_P3_KEY);
- 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(XOO_X1).setReset(true);
- activate(activation, XOO_P2_KEY);
- 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(XOO_X1).setReset(true);
- activate(activation, XOO_P1_KEY);
-
- verifyZeroActiveRules(XOO_P1_KEY);
- verifyZeroActiveRules(XOO_P2_KEY);
- }
-
- @Test
- public void bulk_activation() {
- // Generate more rules than the search's max limit
- int bulkSize = SearchOptions.MAX_LIMIT + 10;
- List<RuleKey> keys = new ArrayList<>();
- for (int i = 0; i < bulkSize; i++) {
- RuleDefinitionDto ruleDefinitionDto = newDto(RuleKey.of("bulk", "r_" + i)).setLanguage("xoo").getDefinition();
- db.ruleDao().insert(dbSession, ruleDefinitionDto);
- keys.add(ruleDefinitionDto.getKey());
- }
- dbSession.commit();
- ruleIndexer.indexRuleDefinitions(keys);
-
- // 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(asList("bulk")), new SearchOptions()).getTotal())
- .isEqualTo(bulkSize);
-
- // 1. bulk activate all the rules
- BulkChangeResult result = ruleActivator.bulkActivate(
- new RuleQuery().setRepositories(asList("bulk")), XOO_P1_KEY, "MINOR");
-
- // 2. assert that all activation has been commit to DB and ES
- dbSession.clearCache();
- assertThat(db.activeRuleDao().selectByProfileKey(dbSession, XOO_P1_KEY)).hasSize(bulkSize);
- assertThat(db.activeRuleDao().selectByProfileKey(dbSession, XOO_P1_KEY)).hasSize(bulkSize);
- assertThat(result.countSucceeded()).isEqualTo(bulkSize);
- assertThat(result.countFailed()).isEqualTo(0);
- }
-
- @Test
- public void bulk_activation_ignores_errors() {
- // 1. bulk activate all the rules, even non xoo-rules and xoo templates
- BulkChangeResult result = ruleActivator.bulkActivate(new RuleQuery(), XOO_P1_KEY, "MINOR");
-
- // 2. assert that all activations have been commit to DB and ES
- // -> xoo rules x1, x2 and custom1
- dbSession.clearCache();
- assertThat(db.activeRuleDao().selectByProfileKey(dbSession, 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(XOO_X1);
- activation.setSeverity("MAJOR");
- activate(activation, XOO_P1_KEY);
- verifyOneActiveRuleInDb(XOO_P1_KEY, XOO_X1, MAJOR, null, ImmutableMap.of("max", "10"));
-
- // create profile P2 with x2
- db.qualityProfileDao().insert(dbSession, QProfileTesting.newXooP2("org-123"));
- activation = new RuleActivation(XOO_X2);
- activation.setSeverity("MAJOR");
- activate(activation, XOO_P2_KEY);
-
- // set parent -> child profile inherits rule x1 and still has x2
- ruleActivator.setParent(dbSession, XOO_P2_KEY, XOO_P1_KEY);
- dbSession.clearCache();
- assertThat(db.qualityProfileDao().selectByUuid(dbSession, XOO_P2_KEY).getParentKee()).isEqualTo(XOO_P1_KEY);
-
- 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(dbSession, XOO_P2_KEY, null);
- assertThat(countActiveRules(XOO_P2_KEY)).isEqualTo(1);
- assertThat(db.qualityProfileDao().selectByUuid(dbSession, XOO_P2_KEY).getParentKee()).isNull();
- verifyHasActiveRuleInDbAndIndex(ActiveRuleKey.of(XOO_P2_KEY, XOO_X2), MAJOR, null, Collections.emptyMap());
- }
-
- @Test
- public void unset_no_parent_does_not_fail() {
- // P1 has no parent !
- ruleActivator.setParent(dbSession, XOO_P1_KEY, null);
- assertThat(db.qualityProfileDao().selectByUuid(dbSession, XOO_P1_KEY).getParentKee()).isNull();
- }
-
- @Test
- public void fail_if_set_child_as_parent() {
- createChildProfiles();
-
- try {
- ruleActivator.setParent(dbSession, XOO_P1_KEY, XOO_P3_KEY);
- fail();
- } catch (BadRequestException e) {
- assertThat(e).hasMessage("Descendant profile 'XOO_P3' can not be selected as parent of 'XOO_P1'");
- }
- }
-
- @Test
- public void keep_overridden_rules_when_unsetting_parent() {
- // x1 is activated on the "future parent"
- RuleActivation activation = new RuleActivation(XOO_X1);
- activation.setSeverity("MAJOR");
- activate(activation, XOO_P1_KEY);
- verifyOneActiveRuleInDb(XOO_P1_KEY, XOO_X1, MAJOR, null, ImmutableMap.of("max", "10"));
-
- // create empty profile P2
- db.qualityProfileDao().insert(dbSession, QProfileTesting.newXooP2("org-123"));
- dbSession.commit();
- dbSession.clearCache();
-
- // set parent -> child profile inherits rule x1
- ruleActivator.setParent(dbSession, XOO_P2_KEY, XOO_P1_KEY);
- verifyOneActiveRuleInDbAndIndex(XOO_P2_KEY, XOO_X1, MAJOR, INHERITED, ImmutableMap.of("max", "10"));
-
- // override x1
- activation = new RuleActivation(XOO_X1);
- activation.setSeverity("BLOCKER").setParameter("max", "333");
- activate(activation, XOO_P2_KEY);
- verifyOneActiveRuleInDb(XOO_P2_KEY, XOO_X1, BLOCKER, OVERRIDES, ImmutableMap.of("max", "333"));
-
- // unset parent -> keep x1
- ruleActivator.setParent(dbSession, XOO_P2_KEY, null);
- dbSession.clearCache();
- assertThat(db.qualityProfileDao().selectByUuid(dbSession, XOO_P2_KEY).getParentKee()).isNull();
- 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(XOO_X1).setSeverity("MAJOR");
- activate(activation, XOO_P1_KEY);
- activation = new RuleActivation(XOO_X2).setSeverity("MAJOR");
- activate(activation, XOO_P1_KEY);
-
- // create profile P2
- db.qualityProfileDao().insert(dbSession, QProfileTesting.newXooP2("org-123"));
-
- // mark rule x1 as REMOVED
- RuleDefinitionDto rule = db.ruleDao().selectOrFailDefinitionByKey(dbSession, XOO_X1);
- rule.setStatus(RuleStatus.REMOVED);
- db.ruleDao().update(dbSession, rule);
- dbSession.commit();
- dbSession.clearCache();
-
- // set parent -> child profile inherits x2 but not x1
- ruleActivator.setParent(dbSession, XOO_P2_KEY, XOO_P1_KEY);
- dbSession.clearCache();
-
- assertThat(db.qualityProfileDao().selectByUuid(dbSession, XOO_P2_KEY).getParentKee()).isEqualTo(XOO_P1_KEY);
- assertThat(countActiveRules(XOO_P2_KEY)).isEqualTo(1);
- verifyHasActiveRuleInDbAndIndex(ActiveRuleKey.of(XOO_P2_KEY, XOO_X2), MAJOR, INHERITED, Collections.emptyMap());
- }
-
- @Test
- public void bulk_deactivate() {
- 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);
-
- dbSession.clearCache();
- assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(0);
- assertThat(result.countFailed()).isEqualTo(0);
- assertThat(result.countSucceeded()).isEqualTo(2);
- assertThat(result.getChanges()).hasSize(2);
- }
-
- @Test
- public void bulk_deactivation_ignores_errors() {
- // activate on parent profile P1
- createChildProfiles();
- activate(new RuleActivation(XOO_X1), XOO_P1_KEY);
- assertThat(countActiveRules(XOO_P2_KEY)).isEqualTo(1);
-
- // bulk deactivate on child profile P2 -> not possible
- BulkChangeResult result = ruleActivator.bulkDeactivate(new RuleQuery().setActivation(true).setQProfileKey(XOO_P2_KEY), XOO_P2_KEY);
-
- dbSession.clearCache();
- assertThat(countActiveRules(XOO_P2_KEY)).isEqualTo(1);
- assertThat(result.countFailed()).isEqualTo(1);
- assertThat(result.countSucceeded()).isEqualTo(0);
- assertThat(result.getChanges()).hasSize(0);
- }
-
- @Test
- public void bulk_change_severity() {
- createChildProfiles();
-
- // activate two rules on root profile P1 (propagated to P2 and P3)
- RuleActivation activation = new RuleActivation(XOO_X1).setSeverity(INFO).setParameter("max", "7");
- activate(activation, XOO_P1_KEY);
- activation = new RuleActivation(XOO_X2).setSeverity(INFO);
- activate(activation, XOO_P1_KEY);
-
- // bulk change severity to BLOCKER. Parameters are not set.
- RuleQuery query = new RuleQuery().setActivation(true).setQProfileKey(XOO_P1_KEY);
- BulkChangeResult result = ruleActivator.bulkActivate(query, XOO_P1_KEY, "BLOCKER");
- assertThat(result.countSucceeded()).isEqualTo(2);
-
- 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.<String, String>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.<String, String>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.<String, String>emptyMap());
- }
-
- private int countActiveRules(String profileKey) {
- List<ActiveRuleDto> activeRuleDtos = db.activeRuleDao().selectByProfileKey(dbSession, profileKey);
- return activeRuleDtos.size();
- }
-
- private void verifyOneActiveRuleInDb(String profileKey, RuleKey ruleKey, String expectedSeverity,
- @Nullable String expectedInheritance, Map<String, String> expectedParams) {
- assertThat(countActiveRules(profileKey)).isEqualTo(1);
- verifyHasActiveRuleInDb(ActiveRuleKey.of(profileKey, ruleKey), expectedSeverity, expectedInheritance, expectedParams);
- }
-
- private void verifyOneActiveRuleInDbAndIndex(String profileKey, RuleKey ruleKey, String expectedSeverity,
- @Nullable String expectedInheritance, Map<String, String> expectedParams) {
- assertThat(countActiveRules(profileKey)).isEqualTo(1);
- verifyHasActiveRuleInDbAndIndex(ActiveRuleKey.of(profileKey, ruleKey), expectedSeverity, expectedInheritance, expectedParams);
- }
-
- private void verifyHasActiveRuleInDb(ActiveRuleKey activeRuleKey, String expectedSeverity,
- @Nullable String expectedInheritance, Map<String, String> expectedParams) {
- // verify db
- boolean found = false;
- List<ActiveRuleDto> 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();
-
- List<ActiveRuleParamDto> paramDtos = db.activeRuleDao().selectParamsByActiveRuleId(dbSession, activeRuleDto.getId());
- assertThat(paramDtos).hasSize(expectedParams.size());
- for (Map.Entry<String, String> entry : expectedParams.entrySet()) {
- 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<RuleKey> ruleKeys = newArrayList(tester.get(RuleIndex.class).searchAll(
- new RuleQuery()
- .setKey(activeRuleKey.ruleKey().toString())
- .setQProfileKey(activeRuleKey.qProfile())
- .setActivation(true)
- .setInheritance(singleton(expectedInheritance == null ? ActiveRule.Inheritance.NONE.name() : ActiveRule.Inheritance.valueOf(expectedInheritance).name()))
- .setActiveSeverities(singleton(expectedSeverity))));
- assertThat(ruleKeys).as("Rule is not activated in index").hasSize(1);
- }
-
- private void verifyHasActiveRuleInDbAndIndex(ActiveRuleKey activeRuleKey, String expectedSeverity,
- @Nullable String expectedInheritance, Map<String, String> expectedParams) {
- verifyHasActiveRuleInDb(activeRuleKey, expectedSeverity, expectedInheritance, expectedParams);
- verifyHasActiveRuleInIndex(activeRuleKey, expectedSeverity, expectedInheritance);
- }
-
- private void createChildProfiles() {
- db.qualityProfileDao().insert(dbSession, QProfileTesting.newXooP2("org-123").setParentKee(XOO_P1_KEY));
- db.qualityProfileDao().insert(dbSession, QProfileTesting.newXooP3("org-123").setParentKee(XOO_P2_KEY));
- dbSession.commit();
- }
-
- private List<ActiveRuleChange> activate(RuleActivation activation, String profileKey) {
- List<ActiveRuleChange> 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<ActiveRuleDto> activeRuleDtos = db.activeRuleDao().selectByProfileKey(dbSession, key);
- assertThat(activeRuleDtos).isEmpty();
-
- // verify es
- assertThat(tester.get(RuleIndex.class).searchAll(
- new RuleQuery()
- .setQProfileKey(key)
- .setActivation(true))).isEmpty();
- }
-
- private void assertProfileHasBeenUpdatedManually(String profileKey) {
- QProfileDto profile = db.qualityProfileDao().selectByUuid(dbSession, profileKey);
- assertThat(profile.getRulesUpdatedAt()).isNotEmpty();
- assertThat(profile.getUserUpdatedAt()).isNotNull();
- }
-
- private void assertProfileHasBeenUpdatedAutomatically(String profileKey) {
- QProfileDto profile = db.qualityProfileDao().selectByUuid(dbSession, profileKey);
- assertThat(profile.getRulesUpdatedAt()).isNotEmpty();
- assertThat(profile.getUserUpdatedAt()).isNull();
- }
+// static final RuleKey TEMPLATE_RULE_KEY = RuleKey.of("xoo", "template1");
+// static final RuleKey CUSTOM_RULE_KEY = RuleKey.of("xoo", "custom1");
+//
+// @ClassRule
+// public static ServerTester tester = new ServerTester().withEsIndexes();
+//
+// @Rule
+// public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
+//
+// DbClient db;
+// DbSession dbSession;
+//
+// RuleActivator ruleActivator;
+//
+// RuleIndexer ruleIndexer;
+//
+// ActiveRuleIndexer activeRuleIndexer;
+//
+// QProfileDto profileDto;
+// private OrganizationDto organization;
+//
+// @Before
+// public void before() {
+// tester.clearDbAndIndexes();
+// db = tester.get(DbClient.class);
+// dbSession = db.openSession(false);
+// ruleActivator = tester.get(RuleActivator.class);
+// activeRuleIndexer = tester.get(ActiveRuleIndexer.class);
+// ruleIndexer = tester.get(RuleIndexer.class);
+// String defaultOrganizationUuid = tester.get(DefaultOrganizationProvider.class).get().getUuid();
+// organization = db.organizationDao().selectByUuid(dbSession, defaultOrganizationUuid).orElseThrow(() -> new IllegalStateException(String.format("Cannot find default organization '%s'", defaultOrganizationUuid)));
+//
+// // create pre-defined rules
+// RuleDto javaRule = newDto(RuleKey.of("squid", "j1"))
+// .setSeverity("MAJOR").setLanguage("java");
+// RuleDto xooRule1 = newXooX1().setSeverity("MINOR");
+// RuleDto xooRule2 = newXooX2().setSeverity("INFO");
+// RuleDto xooTemplateRule1 = newTemplateRule(TEMPLATE_RULE_KEY)
+// .setSeverity("MINOR").setLanguage("xoo");
+//
+// // store pre-defined rules in database
+// asList(javaRule, xooRule1, xooRule2, xooTemplateRule1).stream()
+// .map(RuleDto::getDefinition)
+// .forEach(definition -> db.ruleDao().insert(dbSession, definition));
+// db.ruleDao().insertRuleParam(dbSession, xooRule1.getDefinition(), RuleParamDto.createFor(xooRule1.getDefinition())
+// .setName("max").setDefaultValue("10").setType(RuleParamType.INTEGER.type()));
+// db.ruleDao().insertRuleParam(dbSession, xooRule1.getDefinition(), RuleParamDto.createFor(xooRule1.getDefinition())
+// .setName("min").setType(RuleParamType.INTEGER.type()));
+// db.ruleDao().insertRuleParam(dbSession, xooTemplateRule1.getDefinition(), RuleParamDto.createFor(xooTemplateRule1.getDefinition())
+// .setName("format").setType(RuleParamType.STRING.type()));
+//
+// // create custom rule
+// RuleDto xooCustomRule1 = newCustomRule(xooTemplateRule1).setRuleKey(CUSTOM_RULE_KEY.rule())
+// .setSeverity("MINOR").setLanguage("xoo");
+//
+// // store custom rule in database
+// db.ruleDao().insert(dbSession, xooCustomRule1.getDefinition());
+// db.ruleDao().insertRuleParam(dbSession, xooCustomRule1.getDefinition(), RuleParamDto.createFor(xooTemplateRule1.getDefinition())
+// .setName("format").setDefaultValue("txt").setType(RuleParamType.STRING.type()));
+//
+// // create pre-defined profile P1
+// profileDto = QProfileTesting.newXooP1(organization);
+// db.qualityProfileDao().insert(dbSession, profileDto);
+//
+// // index all rules
+// dbSession.commit();
+// ruleIndexer.indexRuleDefinitions(Stream.of(javaRule, xooRule1, xooRule2, xooTemplateRule1, xooCustomRule1).map(RuleDto::getKey).collect(Collectors.toList()));
+// }
+//
+// @After
+// public void after() {
+// dbSession.close();
+// }
+//
+// @Test
+// public void activate() {
+// RuleActivation activation = new RuleActivation(XOO_X1);
+// activation.setSeverity(BLOCKER);
+// activation.setParameter("max", "7");
+// activation.setParameter("min", "3");
+// List<ActiveRuleChange> changes = ruleActivator.activate(dbSession, activation, XOO_P1_KEY);
+// dbSession.commit();
+// dbSession.clearCache();
+//
+// assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(1);
+// 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);
+// }
+//
+// @Test
+// public void automatic_activation_does_not_update_intended_column() {
+// RuleActivation activation = new RuleActivation(XOO_X1);
+// activation.setSeverity(BLOCKER);
+// activation.setParameter("max", "7");
+// activation.setParameter("min", "3");
+// List<ActiveRuleChange> changes = ruleActivator.activate(dbSession, activation, XOO_P1_KEY);
+// dbSession.commit();
+// dbSession.clearCache();
+// userSessionRule.anonymous();
+//
+// assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(1);
+// 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);
+// assertProfileHasBeenUpdatedAutomatically(XOO_P1_KEY);
+// }
+//
+// @Test
+// public void activate_with_profile_dto() {
+// RuleActivation activation = new RuleActivation(XOO_X1);
+// activation.setSeverity(BLOCKER);
+// activation.setParameter("max", "7");
+// activation.setParameter("min", "3");
+// userSessionRule.logIn().setRoot();
+// List<ActiveRuleChange> changes = ruleActivator.activate(dbSession, activation, profileDto);
+// dbSession.commit();
+// dbSession.clearCache();
+//
+// assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(1);
+// 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);
+// assertProfileHasBeenUpdatedManually(profileDto.getKee());
+// }
+//
+// @Test
+// public void activate_with_default_severity_and_parameter() {
+// activate(new RuleActivation(XOO_X1), XOO_P1_KEY);
+//
+// assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(1);
+// verifyHasActiveRuleInDb(ActiveRuleKey.of(XOO_P1_KEY, XOO_X1), MINOR, null,
+// ImmutableMap.of("max", "10"));
+// }
+//
+// /**
+// * SONAR-5841
+// */
+// @Test
+// public void activate_with_empty_parameter_having_no_default_value() {
+// activate(new RuleActivation(XOO_X1)
+// .setParameter("min", ""),
+// XOO_P1_KEY);
+//
+// assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(1);
+// verifyHasActiveRuleInDb(ActiveRuleKey.of(XOO_P1_KEY, XOO_X1), MINOR, null,
+// // Max should be set to default value, min has no value it should be ignored
+// ImmutableMap.of("max", "10"));
+// }
+//
+// /**
+// * SONAR-5841
+// */
+// @Test
+// public void activate_with_empty_parameters() {
+// 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
+// verifyHasActiveRuleInDb(ActiveRuleKey.of(XOO_P1_KEY, XOO_X1), MINOR, null,
+// ImmutableMap.of("max", "10"));
+// }
+//
+// /**
+// * SONAR-5840
+// */
+// @Test
+// public void activate_rule_with_negative_integer_value_on_parameter_having_no_default_value() {
+// 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
+// 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(XOO_X1);
+// activation.setParameter("xxx", "yyy");
+// activate(activation, XOO_P1_KEY);
+//
+// assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(1);
+// 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(XOO_X1);
+// activation.setSeverity(BLOCKER);
+// activate(activation, XOO_P1_KEY);
+//
+// // update
+// RuleActivation update = new RuleActivation(XOO_X1);
+// update.setSeverity(CRITICAL);
+// update.setParameter("max", "42");
+// List<ActiveRuleChange> changes = activate(update, XOO_P1_KEY);
+//
+// assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(1);
+// 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);
+// }
+//
+// @Test
+// public void update_activation_with_parameter_without_default_value() {
+// // initial activation -> param "max" has a default value
+// RuleActivation activation = new RuleActivation(XOO_X1);
+// activation.setSeverity(BLOCKER);
+// activate(activation, XOO_P1_KEY);
+// 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(XOO_X1);
+// update.setParameter("min", "3");
+// List<ActiveRuleChange> changes = activate(update, XOO_P1_KEY);
+// assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(1);
+// 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);
+// }
+//
+// @Test
+// public void update_activation_remove_parameter_value_having_default_value() {
+// // initial activation
+// activate(new RuleActivation(XOO_X1).setSeverity(BLOCKER).setParameter("max", "20"), XOO_P1_KEY);
+//
+// // update
+// activate(new RuleActivation(XOO_X1).setParameter("max", null), XOO_P1_KEY);
+//
+// verifyHasActiveRuleInDb(ActiveRuleKey.of(XOO_P1_KEY, XOO_X1), BLOCKER, null, ImmutableMap.of("max", "10"));
+// }
+//
+// @Test
+// public void update_activation_remove_parameter_value_without_default_value() {
+// // initial activation -> param "min" has a no default value
+// activate(new RuleActivation(XOO_X1).setSeverity(BLOCKER).setParameter("min", "5"), XOO_P1_KEY);
+//
+// // update param "min" with empty value
+// activate(new RuleActivation(XOO_X1).setParameter("min", null), XOO_P1_KEY);
+//
+// verifyHasActiveRuleInDb(ActiveRuleKey.of(XOO_P1_KEY, XOO_X1), BLOCKER, null, ImmutableMap.of("max", "10"));
+// }
+//
+// @Test
+// public void update_activation_but_new_parameter() {
+// // initial activation
+// 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.activeRuleDao().selectParamByKeyAndName(activeRuleKey, "max", dbSession)).isNotNull();
+// // FIXME db.activeRuleDao().deleteParamByKeyAndName(dbSession, activeRuleKey, "max");
+// dbSession.commit();
+// assertThat(db.activeRuleDao().selectParamByKeyAndName(activeRuleKey, "max", dbSession)).isNull();
+// dbSession.clearCache();
+//
+// // update
+// 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);
+// verifyHasActiveRuleInDb(activeRuleKey, CRITICAL, null, ImmutableMap.of("max", "42"));
+// }
+//
+// @Test
+// public void ignore_activation_without_changes() {
+// // initial activation
+// 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(XOO_X1);
+// update.setSeverity(BLOCKER);
+// List<ActiveRuleChange> changes = activate(update, XOO_P1_KEY);
+// assertThat(changes).isEmpty();
+// }
+//
+// @Test
+// public void do_not_change_severity_and_params_if_unset_and_already_activated() {
+// // initial activation
+// 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(XOO_X1);
+// activate(update, XOO_P1_KEY);
+//
+// assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(1);
+// 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, 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(XOO_X1).setReset(true);
+// activate(update, XOO_P1_KEY);
+// assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(1);
+// verifyHasActiveRuleInDb(activeRuleKey, MINOR, null,
+// // only default values
+// ImmutableMap.of("max", "10"));
+// }
+//
+// @Test
+// public void ignore_parameters_when_activating_custom_rule() {
+// // initial activation
+// ActiveRuleKey activeRuleKey = ActiveRuleKey.of(XOO_P1_KEY, CUSTOM_RULE_KEY);
+// RuleActivation activation = new RuleActivation(CUSTOM_RULE_KEY);
+// activate(activation, XOO_P1_KEY);
+//
+// // update
+// RuleActivation update = new RuleActivation(CUSTOM_RULE_KEY)
+// .setParameter("format", "xls");
+// activate(update, XOO_P1_KEY);
+//
+// assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(1);
+// verifyHasActiveRuleInDb(activeRuleKey, MINOR, null, ImmutableMap.of("format", "txt"));
+// }
+//
+// @Test
+// public void fail_to_activate_if_template() {
+// RuleActivation activation = new RuleActivation(TEMPLATE_RULE_KEY);
+//
+// try {
+// activate(activation, XOO_P1_KEY);
+// fail();
+// } catch (BadRequestException e) {
+// assertThat(e).hasMessage("Rule template can't be activated on a Quality profile: xoo:template1");
+// verifyZeroActiveRules(XOO_P1_KEY);
+// }
+// }
+//
+// @Test
+// public void fail_to_activate_if_different_languages() {
+// // profile and rule have different languages
+// RuleActivation activation = new RuleActivation(RuleKey.of("squid", "j1"));
+//
+// try {
+// activate(activation, XOO_P1_KEY);
+// fail();
+// } catch (BadRequestException e) {
+// assertThat(e).hasMessage("Rule squid:j1 and profile XOO_P1 have different languages");
+// verifyZeroActiveRules(XOO_P1_KEY);
+// }
+// }
+//
+// @Test
+// public void fail_to_activate_if_unknown_rule() {
+// // profile and rule have different languages
+// RuleActivation activation = new RuleActivation(RuleKey.of("xoo", "x3"));
+//
+// try {
+// activate(activation, XOO_P1_KEY);
+// fail();
+// } catch (BadRequestException e) {
+// assertThat(e).hasMessage("Rule not found: xoo:x3");
+// verifyZeroActiveRules(XOO_P1_KEY);
+// }
+// }
+//
+// @Test
+// public void fail_to_activate_if_rule_with_removed_status() {
+// RuleDefinitionDto ruleDto = db.ruleDao().selectOrFailDefinitionByKey(dbSession, XOO_X1);
+// ruleDto.setStatus(RuleStatus.REMOVED);
+// db.ruleDao().update(dbSession, ruleDto);
+// dbSession.commit();
+// dbSession.clearCache();
+//
+// RuleActivation activation = new RuleActivation(XOO_X1);
+//
+// try {
+// activate(activation, XOO_P1_KEY);
+// fail();
+// } catch (BadRequestException e) {
+// assertThat(e).hasMessage("Rule was removed: xoo:x1");
+// verifyZeroActiveRules(XOO_P1_KEY);
+// }
+// }
+//
+// @Test
+// public void fail_to_activate_if_unknown_profile() {
+// try {
+// activate(new RuleActivation(XOO_X1), "unknown");
+// fail();
+// } catch (BadRequestException e) {
+// assertThat(e).hasMessage("Quality profile not found: unknown");
+// }
+// }
+//
+// @Test
+// public void fail_to_activate_if_invalid_parameter() {
+// RuleActivation activation = new RuleActivation(XOO_X1);
+// activation.setParameter("max", "foo");
+//
+// try {
+// activate(activation, XOO_P1_KEY);
+// fail();
+// } catch (BadRequestException e) {
+// assertThat(e.getMessage()).isEqualTo("Value 'foo' must be an integer.");
+// verifyZeroActiveRules(XOO_P1_KEY);
+// }
+// }
+//
+// @Test
+// public void deactivate() {
+// // activation
+// RuleActivation activation = new RuleActivation(XOO_X1);
+// activation.setSeverity(BLOCKER);
+// activation.setParameter("max", "7");
+// userSessionRule.logIn();
+// activate(activation, XOO_P1_KEY);
+//
+// // deactivation
+// ruleActivator.deactivateAndUpdateIndex(dbSession, ActiveRuleKey.of(XOO_P1_KEY, XOO_X1));
+//
+// verifyZeroActiveRules(XOO_P1_KEY);
+// assertProfileHasBeenUpdatedManually(XOO_P1_KEY);
+// }
+//
+// @Test
+// public void ignore_deactivation_if_rule_not_activated() {
+// // deactivation
+// ActiveRuleKey key = ActiveRuleKey.of(XOO_P1_KEY, XOO_X1);
+// ruleActivator.deactivateAndUpdateIndex(dbSession, key);
+//
+// verifyZeroActiveRules(XOO_P1_KEY);
+// }
+//
+// @Test
+// public void deactivation_fails_if_rule_not_found() {
+// ActiveRuleKey key = ActiveRuleKey.of(XOO_P1_KEY, RuleKey.of("xoo", "x3"));
+// try {
+// ruleActivator.deactivateAndUpdateIndex(dbSession, key);
+// fail();
+// } catch (BadRequestException e) {
+// assertThat(e).hasMessage("Rule not found: xoo:x3");
+// verifyZeroActiveRules(XOO_P1_KEY);
+// }
+// }
+//
+// @Test
+// public void deactivation_fails_if_profile_not_found() {
+// ActiveRuleKey key = ActiveRuleKey.of("unknown", XOO_X1);
+// try {
+// ruleActivator.deactivateAndUpdateIndex(dbSession, key);
+// fail();
+// } catch (BadRequestException e) {
+// assertThat(e).hasMessage("Quality profile not found: unknown");
+// }
+// }
+//
+// @Test
+// public void allow_to_deactivate_removed_rule() {
+// // activation
+// RuleActivation activation = new RuleActivation(XOO_X1);
+// activate(activation, XOO_P1_KEY);
+//
+// // set rule as removed
+// RuleDefinitionDto rule = db.ruleDao().selectOrFailDefinitionByKey(dbSession, XOO_X1);
+// rule.setStatus(RuleStatus.REMOVED);
+// db.ruleDao().update(dbSession, rule);
+// dbSession.commit();
+// dbSession.clearCache();
+//
+// // deactivation
+// ruleActivator.deactivateAndUpdateIndex(dbSession, ActiveRuleKey.of(XOO_P1_KEY, XOO_X1));
+//
+// verifyZeroActiveRules(XOO_P1_KEY);
+// }
+//
+// // INHERITANCE OF PROFILES
+// @Test
+// public void activate_on_child_profile_but_not_on_parent() {
+// createChildProfiles();
+//
+// // activate on child profile, but not on root
+// RuleActivation activation = new RuleActivation(XOO_X1);
+// activation.setSeverity(BLOCKER);
+// activation.setParameter("max", "7");
+// activate(activation, XOO_P2_KEY);
+//
+// verifyZeroActiveRules(XOO_P1_KEY);
+// 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(XOO_X1);
+// activation.setSeverity(MINOR);
+// activation.setParameter("max", "77");
+// activate(activation, XOO_P2_KEY);
+//
+// verifyZeroActiveRules(XOO_P1_KEY);
+// 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
+// public void propagate_activation_on_child_profiles() {
+// createChildProfiles();
+//
+// // activate on root profile
+// RuleActivation activation = new RuleActivation(XOO_X1);
+// activation.setSeverity(BLOCKER);
+// activation.setParameter("max", "7");
+// List<ActiveRuleChange> changes = activate(activation, XOO_P1_KEY);
+//
+// assertThat(changes).hasSize(3);
+// 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
+// public void propagate_activation_update_on_child_profiles() {
+// createChildProfiles();
+// userSessionRule.logIn();
+//
+// // activate on root profile
+// RuleActivation activation = new RuleActivation(XOO_X1);
+// activation.setSeverity(BLOCKER);
+// activation.setParameter("max", "7");
+// activate(activation, XOO_P1_KEY);
+// 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(XOO_X1);
+// activation.setSeverity(INFO);
+// activation.setParameter("max", "8");
+// activate(activation, XOO_P1_KEY);
+//
+// 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(XOO_X1);
+// activation.setSeverity(MINOR);
+// activation.setParameter("max", "9");
+// activate(activation, XOO_P2_KEY);
+//
+// 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(XOO_X1);
+// activation.setSeverity(BLOCKER);
+// activation.setParameter("max", "10");
+// activate(activation, XOO_P3_KEY);
+//
+// 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"));
+//
+// assertProfileHasBeenUpdatedManually(XOO_P1_KEY);
+// assertProfileHasBeenUpdatedManually(XOO_P2_KEY);
+// assertProfileHasBeenUpdatedManually(XOO_P3_KEY);
+// }
+//
+// @Test
+// public void do_not_propagate_activation_update_on_child_overrides() {
+// createChildProfiles();
+//
+// // activate on root profile P1
+// RuleActivation activation = new RuleActivation(XOO_X1);
+// activation.setSeverity(INFO);
+// activation.setParameter("max", "7");
+// activate(activation, XOO_P1_KEY);
+// 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(XOO_X1);
+// activation.setSeverity(BLOCKER);
+// activation.setParameter("max", "8");
+// activate(activation, XOO_P2_KEY);
+// 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(XOO_X1);
+// activation.setSeverity(CRITICAL);
+// activation.setParameter("max", "9");
+// activate(activation, XOO_P1_KEY);
+// 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(XOO_X1).setReset(true);
+// activate(activation, XOO_P1_KEY);
+//
+// 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
+// public void active_on_parent_a_rule_already_activated_on_child() {
+// createChildProfiles();
+//
+// // activate on child profile
+// RuleActivation activation = new RuleActivation(XOO_X1);
+// activation.setSeverity(INFO);
+// activation.setParameter("max", "7");
+// activate(activation, XOO_P2_KEY);
+// verifyZeroActiveRules(XOO_P1_KEY);
+// 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(XOO_X1);
+// activation.setSeverity(MAJOR);
+// activation.setParameter("max", "8");
+// activate(activation, XOO_P1_KEY);
+// 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
+// public void do_not_override_on_child_if_same_values() {
+// createChildProfiles();
+//
+// // activate on root profile
+// RuleActivation activation = new RuleActivation(XOO_X1);
+// activation.setSeverity(INFO);
+// activation.setParameter("max", "7");
+// activate(activation, XOO_P1_KEY);
+// 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(XOO_X1);
+// activation.setSeverity(INFO);
+// activation.setParameter("max", "7");
+// activate(activation, XOO_P2_KEY);
+// 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
+// public void propagate_deactivation_on_child_profiles() {
+// createChildProfiles();
+//
+// // activate on root profile
+// RuleActivation activation = new RuleActivation(XOO_X1);
+// activation.setSeverity(BLOCKER);
+// activation.setParameter("max", "7");
+// activate(activation, XOO_P1_KEY);
+// 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.deactivateAndUpdateIndex(dbSession, ActiveRuleKey.of(XOO_P1_KEY, XOO_X1));
+//
+// verifyZeroActiveRules(XOO_P1_KEY);
+// verifyZeroActiveRules(XOO_P2_KEY);
+// verifyZeroActiveRules(XOO_P3_KEY);
+// }
+//
+// @Test
+// public void propagate_deactivation_even_on_child_overrides() {
+// createChildProfiles();
+//
+// // activate on root profile
+// RuleActivation activation = new RuleActivation(XOO_X1);
+// activation.setSeverity(INFO);
+// activation.setParameter("max", "7");
+// activate(activation, XOO_P1_KEY);
+// 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(XOO_X1);
+// activation.setSeverity(BLOCKER);
+// activation.setParameter("max", "8");
+// activate(activation, XOO_P2_KEY);
+// 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.deactivateAndUpdateIndex(dbSession, ActiveRuleKey.of(XOO_P1_KEY, XOO_X1));
+// dbSession.clearCache();
+// verifyZeroActiveRules(XOO_P1_KEY);
+// verifyZeroActiveRules(XOO_P2_KEY);
+// verifyZeroActiveRules(XOO_P3_KEY);
+// }
+//
+// @Test
+// public void do_not_deactivate_inherited_or_overridden_rule() {
+// createChildProfiles();
+//
+// // activate on root profile
+// RuleActivation activation = new RuleActivation(XOO_X1);
+// activation.setSeverity(BLOCKER);
+// activation.setParameter("max", "7");
+// activate(activation, XOO_P1_KEY);
+// 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.deactivateAndUpdateIndex(dbSession, ActiveRuleKey.of(XOO_P2_KEY, XOO_X1));
+// fail();
+// } catch (BadRequestException e) {
+// assertThat(e).hasMessage("Cannot deactivate inherited rule 'xoo:x1'");
+// }
+// }
+//
+// @Test
+// public void reset_child_profile() {
+// createChildProfiles();
+//
+// // activate on root profile
+// RuleActivation activation = new RuleActivation(XOO_X1);
+// activation.setSeverity(BLOCKER);
+// activation.setParameter("max", "7");
+// activate(activation, XOO_P1_KEY);
+// 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(XOO_X1);
+// activation.setSeverity(INFO);
+// activation.setParameter("max", "10");
+// activate(activation, XOO_P2_KEY);
+// 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(XOO_X1).setReset(true);
+// activate(activation, XOO_P2_KEY);
+// 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
+// public void reset_is_not_propagated_to_child_overrides() {
+// createChildProfiles();
+//
+// // activate on root profile
+// RuleActivation activation = new RuleActivation(XOO_X1);
+// activation.setSeverity(BLOCKER);
+// activation.setParameter("max", "7");
+// activate(activation, XOO_P1_KEY);
+// 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(XOO_X1);
+// activation.setSeverity(INFO);
+// activation.setParameter("max", "10");
+// activate(activation, XOO_P2_KEY);
+// 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(XOO_X1);
+// activation.setSeverity(MINOR);
+// activation.setParameter("max", "20");
+// activate(activation, XOO_P3_KEY);
+// 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(XOO_X1).setReset(true);
+// activate(activation, XOO_P2_KEY);
+// 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(XOO_X1).setReset(true);
+// activate(activation, XOO_P1_KEY);
+//
+// verifyZeroActiveRules(XOO_P1_KEY);
+// verifyZeroActiveRules(XOO_P2_KEY);
+// }
+//
+// @Test
+// public void bulk_activation() {
+// // Generate more rules than the search's max limit
+// int bulkSize = SearchOptions.MAX_LIMIT + 10;
+// List<RuleKey> keys = new ArrayList<>();
+// for (int i = 0; i < bulkSize; i++) {
+// RuleDefinitionDto ruleDefinitionDto = newDto(RuleKey.of("bulk", "r_" + i)).setLanguage("xoo").getDefinition();
+// db.ruleDao().insert(dbSession, ruleDefinitionDto);
+// keys.add(ruleDefinitionDto.getKey());
+// }
+// dbSession.commit();
+// ruleIndexer.indexRuleDefinitions(keys);
+//
+// // 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(singletonList("bulk")), new SearchOptions()).getTotal())
+// .isEqualTo(bulkSize);
+//
+// // 1. bulk activate all the rules
+// RuleQuery ruleQuery = new RuleQuery().setRepositories(singletonList("bulk"));
+// BulkChangeResult result = ruleActivator.bulkActivate(dbSession, ruleQuery, selectProfile(XOO_P1_KEY), "MINOR");
+//
+// // 2. assert that all activation has been commit to DB and ES
+// dbSession.commit();
+// assertThat(db.activeRuleDao().selectByProfileUuid(dbSession, XOO_P1_KEY)).hasSize(bulkSize);
+// assertThat(result.countSucceeded()).isEqualTo(bulkSize);
+// assertThat(result.countFailed()).isEqualTo(0);
+// }
+//
+// private QProfileDto selectProfile(String uuid) {
+// return db.qualityProfileDao().selectByUuid(dbSession, uuid);
+// }
+//
+// @Test
+// public void bulk_activation_ignores_errors() {
+// // 1. bulk activate all the rules, even non xoo-rules and xoo templates
+// BulkChangeResult result = ruleActivator.bulkActivate(dbSession, new RuleQuery(), selectProfile(XOO_P1_KEY), "MINOR");
+//
+// // 2. assert that all activations have been commit to DB and ES
+// // -> xoo rules x1, x2 and custom1
+// dbSession.commit();
+// assertThat(db.activeRuleDao().selectByProfileUuid(dbSession, 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(XOO_X1);
+// activation.setSeverity("MAJOR");
+// activate(activation, XOO_P1_KEY);
+// verifyOneActiveRuleInDb(XOO_P1_KEY, XOO_X1, MAJOR, null, ImmutableMap.of("max", "10"));
+//
+// // create profile P2 with x2
+// db.qualityProfileDao().insert(dbSession, QProfileTesting.newXooP2("org-123"));
+// activation = new RuleActivation(XOO_X2);
+// activation.setSeverity("MAJOR");
+// activate(activation, XOO_P2_KEY);
+//
+// // set parent -> child profile inherits rule x1 and still has x2
+// ruleActivator.setParent(dbSession, selectProfile(XOO_P2_KEY), selectProfile(XOO_P1_KEY));
+// dbSession.clearCache();
+// assertThat(db.qualityProfileDao().selectByUuid(dbSession, XOO_P2_KEY).getParentKee()).isEqualTo(XOO_P1_KEY);
+//
+// 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(dbSession, selectProfile(XOO_P2_KEY), null);
+// assertThat(countActiveRules(XOO_P2_KEY)).isEqualTo(1);
+// assertThat(db.qualityProfileDao().selectByUuid(dbSession, XOO_P2_KEY).getParentKee()).isNull();
+// verifyHasActiveRuleInDbAndIndex(ActiveRuleKey.of(XOO_P2_KEY, XOO_X2), MAJOR, null, Collections.emptyMap());
+// }
+//
+// @Test
+// public void unset_no_parent_does_not_fail() {
+// // P1 has no parent !
+// ruleActivator.setParent(dbSession, selectProfile(XOO_P1_KEY), null);
+// assertThat(selectProfile(XOO_P1_KEY).getParentKee()).isNull();
+// }
+//
+// @Test
+// public void fail_if_set_child_as_parent() {
+// createChildProfiles();
+//
+// try {
+// ruleActivator.setParent(dbSession, selectProfile(XOO_P1_KEY), selectProfile(XOO_P3_KEY));
+// fail();
+// } catch (BadRequestException e) {
+// assertThat(e).hasMessage("Descendant profile 'XOO_P3' can not be selected as parent of 'XOO_P1'");
+// }
+// }
+//
+// @Test
+// public void keep_overridden_rules_when_unsetting_parent() {
+// // x1 is activated on the "future parent"
+// RuleActivation activation = new RuleActivation(XOO_X1);
+// activation.setSeverity("MAJOR");
+// activate(activation, XOO_P1_KEY);
+// verifyOneActiveRuleInDb(XOO_P1_KEY, XOO_X1, MAJOR, null, ImmutableMap.of("max", "10"));
+//
+// // create empty profile P2
+// db.qualityProfileDao().insert(dbSession, QProfileTesting.newXooP2("org-123"));
+// dbSession.commit();
+// dbSession.clearCache();
+//
+// // set parent -> child profile inherits rule x1
+// ruleActivator.setParent(dbSession, selectProfile(XOO_P2_KEY), selectProfile(XOO_P1_KEY));
+// verifyOneActiveRuleInDbAndIndex(XOO_P2_KEY, XOO_X1, MAJOR, INHERITED, ImmutableMap.of("max", "10"));
+//
+// // override x1
+// activation = new RuleActivation(XOO_X1);
+// activation.setSeverity("BLOCKER").setParameter("max", "333");
+// activate(activation, XOO_P2_KEY);
+// verifyOneActiveRuleInDb(XOO_P2_KEY, XOO_X1, BLOCKER, OVERRIDES, ImmutableMap.of("max", "333"));
+//
+// // unset parent -> keep x1
+// ruleActivator.setParent(dbSession, selectProfile(XOO_P2_KEY), null);
+// dbSession.clearCache();
+// assertThat(db.qualityProfileDao().selectByUuid(dbSession, XOO_P2_KEY).getParentKee()).isNull();
+// 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(XOO_X1).setSeverity("MAJOR");
+// activate(activation, XOO_P1_KEY);
+// activation = new RuleActivation(XOO_X2).setSeverity("MAJOR");
+// activate(activation, XOO_P1_KEY);
+//
+// // create profile P2
+// db.qualityProfileDao().insert(dbSession, QProfileTesting.newXooP2("org-123"));
+//
+// // mark rule x1 as REMOVED
+// RuleDefinitionDto rule = db.ruleDao().selectOrFailDefinitionByKey(dbSession, XOO_X1);
+// rule.setStatus(RuleStatus.REMOVED);
+// db.ruleDao().update(dbSession, rule);
+// dbSession.commit();
+// dbSession.clearCache();
+//
+// // set parent -> child profile inherits x2 but not x1
+// ruleActivator.setParent(dbSession, selectProfile(XOO_P2_KEY), selectProfile(XOO_P1_KEY));
+// dbSession.clearCache();
+//
+// assertThat(db.qualityProfileDao().selectByUuid(dbSession, XOO_P2_KEY).getParentKee()).isEqualTo(XOO_P1_KEY);
+// assertThat(countActiveRules(XOO_P2_KEY)).isEqualTo(1);
+// verifyHasActiveRuleInDbAndIndex(ActiveRuleKey.of(XOO_P2_KEY, XOO_X2), MAJOR, INHERITED, Collections.emptyMap());
+// }
+//
+// @Test
+// public void bulk_deactivate() {
+// 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);
+//
+// dbSession.clearCache();
+// assertThat(countActiveRules(XOO_P1_KEY)).isEqualTo(0);
+// assertThat(result.countFailed()).isEqualTo(0);
+// assertThat(result.countSucceeded()).isEqualTo(2);
+// assertThat(result.getChanges()).hasSize(2);
+// }
+//
+// @Test
+// public void bulk_deactivation_ignores_errors() {
+// // activate on parent profile P1
+// createChildProfiles();
+// activate(new RuleActivation(XOO_X1), XOO_P1_KEY);
+// assertThat(countActiveRules(XOO_P2_KEY)).isEqualTo(1);
+//
+// // bulk deactivate on child profile P2 -> not possible
+// BulkChangeResult result = ruleActivator.bulkDeactivate(new RuleQuery().setActivation(true).setQProfileKey(XOO_P2_KEY), XOO_P2_KEY);
+//
+// dbSession.clearCache();
+// assertThat(countActiveRules(XOO_P2_KEY)).isEqualTo(1);
+// assertThat(result.countFailed()).isEqualTo(1);
+// assertThat(result.countSucceeded()).isEqualTo(0);
+// assertThat(result.getChanges()).hasSize(0);
+// }
+//
+// @Test
+// public void bulk_change_severity() {
+// createChildProfiles();
+//
+// // activate two rules on root profile P1 (propagated to P2 and P3)
+// RuleActivation activation = new RuleActivation(XOO_X1).setSeverity(INFO).setParameter("max", "7");
+// activate(activation, XOO_P1_KEY);
+// activation = new RuleActivation(XOO_X2).setSeverity(INFO);
+// activate(activation, XOO_P1_KEY);
+//
+// // bulk change severity to BLOCKER. Parameters are not set.
+// RuleQuery query = new RuleQuery().setActivation(true).setQProfileKey(XOO_P1_KEY);
+// BulkChangeResult result = ruleActivator.bulkActivate(dbSession, query, selectProfile(XOO_P1_KEY), "BLOCKER");
+// dbSession.commit();
+// assertThat(result.countSucceeded()).isEqualTo(2);
+//
+// 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.<String, String>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.<String, String>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.<String, String>emptyMap());
+// }
+//
+// private int countActiveRules(String profileKey) {
+// List<ActiveRuleDto> activeRuleDtos = db.activeRuleDao().selectByProfileUuid(dbSession, profileKey);
+// return activeRuleDtos.size();
+// }
+//
+// private void verifyOneActiveRuleInDb(String profileKey, RuleKey ruleKey, String expectedSeverity,
+// @Nullable String expectedInheritance, Map<String, String> expectedParams) {
+// assertThat(countActiveRules(profileKey)).isEqualTo(1);
+// verifyHasActiveRuleInDb(ActiveRuleKey.of(profileKey, ruleKey), expectedSeverity, expectedInheritance, expectedParams);
+// }
+//
+// private void verifyOneActiveRuleInDbAndIndex(String profileKey, RuleKey ruleKey, String expectedSeverity,
+// @Nullable String expectedInheritance, Map<String, String> expectedParams) {
+// assertThat(countActiveRules(profileKey)).isEqualTo(1);
+// verifyHasActiveRuleInDbAndIndex(ActiveRuleKey.of(profileKey, ruleKey), expectedSeverity, expectedInheritance, expectedParams);
+// }
+//
+// private void verifyHasActiveRuleInDb(ActiveRuleKey activeRuleKey, String expectedSeverity,
+// @Nullable String expectedInheritance, Map<String, String> expectedParams) {
+// // verify db
+// boolean found = false;
+// List<ActiveRuleDto> activeRuleDtos = db.activeRuleDao().selectByProfileUuid(dbSession, activeRuleKey.getRuleProfileUuid());
+// 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();
+//
+// List<ActiveRuleParamDto> paramDtos = db.activeRuleDao().selectParamsByActiveRuleId(dbSession, activeRuleDto.getId());
+// assertThat(paramDtos).hasSize(expectedParams.size());
+// for (Map.Entry<String, String> entry : expectedParams.entrySet()) {
+// 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<RuleKey> ruleKeys = newArrayList(tester.get(RuleIndex.class).searchAll(
+// new RuleQuery()
+// .setKey(activeRuleKey.getRuleKey().toString())
+// .setQProfileKey(activeRuleKey.getRuleProfileUuid())
+// .setActivation(true)
+// .setInheritance(singleton(expectedInheritance == null ? ActiveRule.Inheritance.NONE.name() : ActiveRule.Inheritance.valueOf(expectedInheritance).name()))
+// .setActiveSeverities(singleton(expectedSeverity))));
+// assertThat(ruleKeys).as("Rule is not activated in index").hasSize(1);
+// }
+//
+// private void verifyHasActiveRuleInDbAndIndex(ActiveRuleKey activeRuleKey, String expectedSeverity,
+// @Nullable String expectedInheritance, Map<String, String> expectedParams) {
+// verifyHasActiveRuleInDb(activeRuleKey, expectedSeverity, expectedInheritance, expectedParams);
+// verifyHasActiveRuleInIndex(activeRuleKey, expectedSeverity, expectedInheritance);
+// }
+//
+// private void createChildProfiles() {
+// db.qualityProfileDao().insert(dbSession, QProfileTesting.newXooP2("org-123").setParentKee(XOO_P1_KEY));
+// db.qualityProfileDao().insert(dbSession, QProfileTesting.newXooP3("org-123").setParentKee(XOO_P2_KEY));
+// dbSession.commit();
+// }
+//
+// private List<ActiveRuleChange> activate(RuleActivation activation, String profileKey) {
+// List<ActiveRuleChange> 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<ActiveRuleDto> activeRuleDtos = db.activeRuleDao().selectByProfileUuid(dbSession, key);
+// assertThat(activeRuleDtos).isEmpty();
+//
+// // verify es
+// assertThat(tester.get(RuleIndex.class).searchAll(
+// new RuleQuery()
+// .setQProfileKey(key)
+// .setActivation(true))).isEmpty();
+// }
+//
+// private void assertProfileHasBeenUpdatedManually(String profileKey) {
+// QProfileDto profile = db.qualityProfileDao().selectByUuid(dbSession, profileKey);
+// assertThat(profile.getRulesUpdatedAt()).isNotEmpty();
+// assertThat(profile.getUserUpdatedAt()).isNotNull();
+// }
+//
+// private void assertProfileHasBeenUpdatedAutomatically(String profileKey) {
+// QProfileDto profile = db.qualityProfileDao().selectByUuid(dbSession, profileKey);
+// assertThat(profile.getRulesUpdatedAt()).isNotEmpty();
+// assertThat(profile.getUserUpdatedAt()).isNull();
+// }
}
+++ /dev/null
-/*
- * SonarQube
- * Copyright (C) 2009-2017 SonarSource SA
- * mailto:info AT sonarsource DOT com
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 3 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-package org.sonar.server.qualityprofile.index;
-
-import org.sonar.api.rule.Severity;
-import org.sonar.db.qualityprofile.ActiveRuleKey;
-import org.sonar.db.rule.RuleTesting;
-
-import static org.apache.commons.lang.RandomStringUtils.randomAlphabetic;
-
-public class ActiveRuleDocTesting {
-
- public static ActiveRuleDoc newDoc() {
- return newDoc(ActiveRuleKey.of("sonar-way", RuleTesting.XOO_X1));
- }
-
- public static ActiveRuleDoc newDoc(ActiveRuleKey key) {
- return new ActiveRuleDoc(key)
- .setOrganizationUuid(randomAlphabetic(40))
- .setSeverity(Severity.CRITICAL)
- .setInheritance(null)
- .setUpdatedAt(1_600_000_000L);
- }
-}
*/
package org.sonar.server.qualityprofile.index;
-import com.google.common.collect.Iterators;
+import java.util.List;
+import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.config.MapSettings;
-import org.sonar.api.rule.RuleKey;
import org.sonar.api.utils.System2;
import org.sonar.db.DbTester;
import org.sonar.db.organization.OrganizationDto;
import org.sonar.db.qualityprofile.ActiveRuleDto;
-import org.sonar.db.qualityprofile.ActiveRuleKey;
import org.sonar.db.qualityprofile.QProfileDto;
+import org.sonar.db.qualityprofile.RulesProfileDto;
import org.sonar.db.rule.RuleDefinitionDto;
-import org.sonar.db.rule.RuleTesting;
import org.sonar.server.es.EsTester;
import org.sonar.server.qualityprofile.ActiveRuleChange;
import org.sonar.server.rule.index.RuleIndexDefinition;
import static java.util.Arrays.asList;
+import static java.util.Collections.emptySet;
import static java.util.Collections.singletonList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.sonar.server.qualityprofile.ActiveRuleChange.Type.ACTIVATED;
import static org.sonar.server.qualityprofile.ActiveRuleChange.Type.DEACTIVATED;
-import static org.sonar.server.qualityprofile.index.ActiveRuleDocTesting.newDoc;
import static org.sonar.server.rule.index.RuleIndexDefinition.INDEX_TYPE_ACTIVE_RULE;
public class ActiveRuleIndexerTest {
- private static final RuleKey RULE_KEY_1 = RuleTesting.XOO_X1;
- private static final RuleKey RULE_KEY_2 = RuleTesting.XOO_X2;
- private static final RuleKey RULE_KEY_3 = RuleTesting.XOO_X3;
- private static final String QUALITY_PROFILE_KEY1 = "qp1";
- private static final String QUALITY_PROFILE_KEY2 = "qp2";
-
private System2 system2 = System2.INSTANCE;
@Rule
- public EsTester esTester = new EsTester(new RuleIndexDefinition(new MapSettings()));
+ public DbTester db = DbTester.create(system2);
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public EsTester es = new EsTester(RuleIndexDefinition.createForTest(new MapSettings()));
+
+ private ActiveRuleIndexer underTest = new ActiveRuleIndexer(db.getDbClient(), es.client(), new ActiveRuleIteratorFactory(db.getDbClient()));
+ private RuleDefinitionDto rule1;
+ private RuleDefinitionDto rule2;
+ private OrganizationDto org;
+ private QProfileDto profile1;
+ private QProfileDto profile2;
+
+ @Before
+ public void before() {
+ rule1 = db.rules().insert();
+ rule2 = db.rules().insert();
+ org = db.organizations().insert();
+ profile1 = db.qualityProfiles().insert(org);
+ profile2 = db.qualityProfiles().insert(org);
+ }
- private ActiveRuleIndexer underTest = new ActiveRuleIndexer(system2, db.getDbClient(), esTester.client());
+ @Test
+ public void getIndexTypes() {
+ assertThat(underTest.getIndexTypes()).containsExactly(RuleIndexDefinition.INDEX_TYPE_ACTIVE_RULE);
+ }
@Test
- public void index_nothing() {
- underTest.index(Iterators.emptyIterator());
- assertThat(esTester.countDocuments(INDEX_TYPE_ACTIVE_RULE)).isZero();
+ public void indexOnStartup_does_nothing_if_no_data() {
+ underTest.indexOnStartup(emptySet());
+ assertThat(es.countDocuments(INDEX_TYPE_ACTIVE_RULE)).isZero();
}
@Test
- public void test_index() {
- RuleDefinitionDto rule = db.rules().insert();
- OrganizationDto org = db.organizations().insert();
- QProfileDto profile = db.qualityProfiles().insert(org);
- db.qualityProfiles().activateRule(profile, rule);
+ public void indexOnStartup_indexes_all_data() {
+ ActiveRuleDto activeRule = db.qualityProfiles().activateRule(profile1, rule1);
- underTest.index();
+ underTest.indexOnStartup(emptySet());
- assertThat(esTester.countDocuments(INDEX_TYPE_ACTIVE_RULE)).isEqualTo(1);
+ List<ActiveRuleDoc> docs = es.getDocuments(INDEX_TYPE_ACTIVE_RULE, ActiveRuleDoc.class);
+ assertThat(docs).hasSize(1);
+ verify(docs.get(0), rule1, profile1, activeRule);
}
@Test
- public void deleteByProfileKeys_deletes_documents_associated_to_specified_profile() throws Exception {
- indexActiveRules(
- newDoc(ActiveRuleKey.of(QUALITY_PROFILE_KEY1, RULE_KEY_1)),
- newDoc(ActiveRuleKey.of(QUALITY_PROFILE_KEY1, RULE_KEY_2)),
- newDoc(ActiveRuleKey.of(QUALITY_PROFILE_KEY2, RULE_KEY_2)),
- newDoc(ActiveRuleKey.of(QUALITY_PROFILE_KEY2, RULE_KEY_3)));
- assertThat(esTester.getIds(INDEX_TYPE_ACTIVE_RULE)).hasSize(4);
-
- underTest.deleteByProfileKeys(asList(QUALITY_PROFILE_KEY1));
-
- assertThat(esTester.getIds(INDEX_TYPE_ACTIVE_RULE)).containsOnly(
- ActiveRuleKey.of(QUALITY_PROFILE_KEY2, RULE_KEY_2).toString(),
- ActiveRuleKey.of(QUALITY_PROFILE_KEY2, RULE_KEY_3).toString());
+ public void deleteByProfiles() throws Exception {
+ ActiveRuleDto activeRule1 = db.qualityProfiles().activateRule(profile1, rule1);
+ ActiveRuleDto activeRule2 = db.qualityProfiles().activateRule(profile2, rule1);
+ ActiveRuleDto activeRule3 = db.qualityProfiles().activateRule(profile2, rule2);
+ index();
+
+ underTest.deleteByProfiles(singletonList(profile2));
+
+ verifyOnlyIndexed(activeRule1);
}
@Test
- public void deleteByProfileKeys_deletes_documents_associated_to_multiple_profiles() throws Exception {
- indexActiveRules(
- newDoc(ActiveRuleKey.of(QUALITY_PROFILE_KEY1, RULE_KEY_1)),
- newDoc(ActiveRuleKey.of(QUALITY_PROFILE_KEY1, RULE_KEY_2)),
- newDoc(ActiveRuleKey.of(QUALITY_PROFILE_KEY2, RULE_KEY_2)),
- newDoc(ActiveRuleKey.of(QUALITY_PROFILE_KEY2, RULE_KEY_3)));
- assertThat(esTester.getIds(INDEX_TYPE_ACTIVE_RULE)).hasSize(4);
+ public void deleteByProfiles_does_nothing_if_profiles_are_not_indexed() throws Exception {
+ ActiveRuleDto activeRule1 = db.qualityProfiles().activateRule(profile1, rule1);
+ ActiveRuleDto activeRule2 = db.qualityProfiles().activateRule(profile2, rule1);
+ ActiveRuleDto activeRule3 = db.qualityProfiles().activateRule(profile2, rule2);
+ assertThat(es.countDocuments(INDEX_TYPE_ACTIVE_RULE)).isEqualTo(0);
- underTest.deleteByProfileKeys(asList(QUALITY_PROFILE_KEY1, QUALITY_PROFILE_KEY2));
+ underTest.deleteByProfiles(singletonList(profile2));
- assertThat(esTester.getIds(INDEX_TYPE_ACTIVE_RULE)).isEmpty();
+ assertThat(es.countDocuments(INDEX_TYPE_ACTIVE_RULE)).isEqualTo(0);
}
@Test
- public void index_from_changes_remove_deactivated_rules() throws Exception {
- ActiveRuleKey activeRuleKey1 = ActiveRuleKey.of(QUALITY_PROFILE_KEY1, RULE_KEY_1);
- ActiveRuleKey activeRuleKey2 = ActiveRuleKey.of(QUALITY_PROFILE_KEY1, RULE_KEY_2);
- ActiveRuleKey activeRuleKey3 = ActiveRuleKey.of(QUALITY_PROFILE_KEY2, RULE_KEY_2);
- ActiveRuleKey activeRuleKey4 = ActiveRuleKey.of(QUALITY_PROFILE_KEY2, RULE_KEY_3);
-
- indexActiveRules(
- newDoc(activeRuleKey1),
- newDoc(activeRuleKey2),
- newDoc(activeRuleKey3),
- newDoc(activeRuleKey4));
-
- assertThat(esTester.getIds(INDEX_TYPE_ACTIVE_RULE)).hasSize(4);
-
- underTest.index(asList(
- ActiveRuleChange.createFor(ACTIVATED, activeRuleKey1),
- ActiveRuleChange.createFor(DEACTIVATED, activeRuleKey2),
- ActiveRuleChange.createFor(DEACTIVATED, activeRuleKey3)));
-
- assertThat(esTester.getIds(INDEX_TYPE_ACTIVE_RULE)).containsOnly(
- activeRuleKey1.toString(),
- activeRuleKey4.toString());
+ public void indexRuleProfile() throws Exception {
+ ActiveRuleDto activeRule1 = db.qualityProfiles().activateRule(profile1, rule1);
+ ActiveRuleDto activeRule2 = db.qualityProfiles().activateRule(profile2, rule1);
+ ActiveRuleDto activeRule3 = db.qualityProfiles().activateRule(profile2, rule2);
+
+ indexProfile(profile2);
+
+ verifyOnlyIndexed(activeRule2, activeRule3);
}
@Test
- public void index_from_changes_index_new_active_rule() throws Exception {
- long yesterday = 1_000;
- long now = 2_000L;
- RuleDefinitionDto rule = db.rules().insert();
- OrganizationDto org = db.organizations().insert();
- QProfileDto profile1 = db.qualityProfiles().insert(org);
- ActiveRuleDto activeRule1 = db.qualityProfiles().activateRule(profile1, rule, ar -> ar.setUpdatedAt(yesterday));
+ public void indexChanges_puts_documents() throws Exception {
+ ActiveRuleDto activeRule1 = db.qualityProfiles().activateRule(profile1, rule1);
+ ActiveRuleDto activeRule2 = db.qualityProfiles().activateRule(profile2, rule1);
+ ActiveRuleDto nonIndexed = db.qualityProfiles().activateRule(profile2, rule2);
+
+ underTest.indexChanges(db.getSession(), asList(
+ newChange(ACTIVATED, activeRule1), newChange(ACTIVATED, activeRule2)));
- underTest.index();
+ verifyOnlyIndexed(activeRule1, activeRule2);
+ }
- assertThat(esTester.getIds(INDEX_TYPE_ACTIVE_RULE)).containsOnly(activeRule1.getKey().toString());
+ @Test
+ public void indexChanges_deletes_documents_when_type_is_DEACTIVATED() throws Exception {
+ ActiveRuleDto activeRule1 = db.qualityProfiles().activateRule(profile1, rule1);
+ ActiveRuleDto activeRule2 = db.qualityProfiles().activateRule(profile2, rule1);
+ underTest.indexChanges(db.getSession(), asList(
+ newChange(ACTIVATED, activeRule1), newChange(ACTIVATED, activeRule2)));
+ assertThat(es.countDocuments(RuleIndexDefinition.INDEX_TYPE_ACTIVE_RULE)).isEqualTo(2);
- // Index another active rule
- QProfileDto profile2 = db.qualityProfiles().insert(org);
- ActiveRuleDto activeRule2 = db.qualityProfiles().activateRule(profile2, rule, ar -> ar.setUpdatedAt(now));
+ underTest.indexChanges(db.getSession(), singletonList(newChange(DEACTIVATED, activeRule1)));
- underTest.index(singletonList(ActiveRuleChange.createFor(ACTIVATED, activeRule2.getKey())));
+ verifyOnlyIndexed(activeRule2);
+ }
+
+ @Test
+ public void deleteByRuleKeys() {
+ ActiveRuleDto active1 = db.qualityProfiles().activateRule(profile1, rule1);
+ ActiveRuleDto active2 = db.qualityProfiles().activateRule(profile2, rule1);
+ ActiveRuleDto onRule2 = db.qualityProfiles().activateRule(profile2, rule2);
+ index();
+
+ underTest.deleteByRuleKeys(singletonList(rule2.getKey()));
+
+ verifyOnlyIndexed(active1, active2);
+ }
+
+ private void verifyOnlyIndexed(ActiveRuleDto... expected) {
+ List<String> docs = es.getIds(INDEX_TYPE_ACTIVE_RULE);
+ assertThat(docs).hasSize(expected.length);
+ for (ActiveRuleDto activeRuleDto : expected) {
+ assertThat(docs).contains(activeRuleDto.getId().toString());
+ }
+ }
+
+ private ActiveRuleChange newChange(ActiveRuleChange.Type type, ActiveRuleDto activeRule) {
+ return new ActiveRuleChange(type, activeRule);
+ }
+
+ private void indexProfile(QProfileDto profile) {
+ underTest.indexRuleProfile(db.getSession(), RulesProfileDto.from(profile));
+ }
- assertThat(esTester.getIds(INDEX_TYPE_ACTIVE_RULE)).containsOnly(
- activeRule1.getKey().toString(),
- activeRule2.getKey().toString());
+ private void verify(ActiveRuleDoc doc1, RuleDefinitionDto rule, QProfileDto profile, ActiveRuleDto activeRule) {
+ assertThat(doc1)
+ .matches(doc -> doc.getRuleKey().equals(rule.getKey()))
+ .matches(doc -> doc.getId().equals("" + activeRule.getId()))
+ .matches(doc -> doc.getRuleProfileUuid().equals(profile.getRulesProfileUuid()))
+ .matches(doc -> doc.getRuleRepository().equals(rule.getRepositoryKey()))
+ .matches(doc -> doc.getSeverity().equals(activeRule.getSeverityString()));
}
- private void indexActiveRules(ActiveRuleDoc... docs) {
- underTest.index(asList(docs).iterator());
+ private void index() {
+ underTest.indexOnStartup(emptySet());
}
}
+++ /dev/null
-/*
- * SonarQube
- * Copyright (C) 2009-2017 SonarSource SA
- * mailto:info AT sonarsource DOT com
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 3 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-package org.sonar.server.qualityprofile.index;
-
-import com.google.common.collect.Maps;
-import java.util.Map;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.sonar.api.utils.System2;
-import org.sonar.db.DbTester;
-import org.sonar.db.organization.OrganizationDto;
-import org.sonar.db.qualityprofile.ActiveRuleDto;
-import org.sonar.db.qualityprofile.ActiveRuleKey;
-import org.sonar.db.qualityprofile.QProfileDto;
-import org.sonar.db.rule.RuleDefinitionDto;
-import org.sonar.server.qualityprofile.ActiveRule;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.sonar.api.rule.Severity.CRITICAL;
-import static org.sonar.server.qualityprofile.ActiveRule.Inheritance.INHERITED;
-
-public class ActiveRuleResultSetIteratorTest {
-
- @Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
-
- private RuleDefinitionDto rule;
- private OrganizationDto org;
- private QProfileDto profile1;
- private QProfileDto profile2;
-
- @Before
- public void before() {
- rule = db.rules().insert();
- org = db.organizations().insert();
- profile1 = db.qualityProfiles().insert(org);
- profile2 = db.qualityProfiles().insert(org);
- }
- @Test
- public void iterate_over_one_active_rule() {
- ActiveRuleDto dto = db.qualityProfiles().activateRule(profile1, rule, ar -> ar.setSeverity(CRITICAL).setInheritance(null));
-
- ActiveRuleResultSetIterator it = ActiveRuleResultSetIterator.create(db.getDbClient(), db.getSession(), 0L);
- Map<ActiveRuleKey, ActiveRuleDoc> activeRulesByKey = activeRulesByKey(it);
- it.close();
-
- assertThat(activeRulesByKey).hasSize(1);
-
- ActiveRuleKey key = ActiveRuleKey.of(profile1.getKee(), rule.getKey());
- ActiveRuleDoc activeRule = activeRulesByKey.get(key);
- assertThat(activeRule.organizationUuid()).isEqualTo(org.getUuid());
- assertThat(activeRule.key()).isEqualTo(key);
- assertThat(activeRule.severity()).isEqualTo(CRITICAL);
- assertThat(activeRule.inheritance()).isEqualTo(ActiveRule.Inheritance.NONE);
- assertThat(activeRule.updatedAt()).isEqualTo(dto.getUpdatedAt());
- }
-
- @Test
- public void iterate_over_multiple_active_rules() {
- ActiveRuleDto dto1 = db.qualityProfiles().activateRule(profile1, rule);
- ActiveRuleDto dto2 = db.qualityProfiles().activateRule(profile2, rule);
-
- ActiveRuleResultSetIterator it = ActiveRuleResultSetIterator.create(db.getDbClient(), db.getSession(), 0L);
- Map<ActiveRuleKey, ActiveRuleDoc> activeRulesByKey = activeRulesByKey(it);
- it.close();
-
- assertThat(activeRulesByKey).hasSize(2);
- assertThat(activeRulesByKey.keySet()).containsExactlyInAnyOrder(dto1.getKey(), dto2.getKey());
- }
-
- @Test
- public void iterate_inherited_active_rule() {
- ActiveRuleDto dto = db.qualityProfiles().activateRule(profile1, rule, ar -> ar.setInheritance(INHERITED.name()));
-
- ActiveRuleResultSetIterator it = ActiveRuleResultSetIterator.create(db.getDbClient(), db.getSession(), 0L);
- Map<ActiveRuleKey, ActiveRuleDoc> activeRulesByKey = activeRulesByKey(it);
- it.close();
-
- assertThat(activeRulesByKey).hasSize(1);
- assertThat(activeRulesByKey.get(dto.getKey()).inheritance()).isEqualTo(INHERITED);
- }
-
- @Test
- public void select_after_date() {
- ActiveRuleDto dto1 = db.qualityProfiles().activateRule(profile1, rule, ar -> ar.setUpdatedAt(1_500L));
- ActiveRuleDto dto2 = db.qualityProfiles().activateRule(profile2, rule, ar -> ar.setUpdatedAt(1_600L));
-
- ActiveRuleResultSetIterator it = ActiveRuleResultSetIterator.create(db.getDbClient(), db.getSession(), 1_550L);
- assertThat(it.hasNext()).isTrue();
- ActiveRuleDoc doc = it.next();
- assertThat(doc.key()).isEqualTo(dto2.getKey());
-
- assertThat(it.hasNext()).isFalse();
- it.close();
- }
-
- private static Map<ActiveRuleKey, ActiveRuleDoc> activeRulesByKey(ActiveRuleResultSetIterator it) {
- return Maps.uniqueIndex(it, ActiveRuleDoc::key);
- }
-
-}
*/
package org.sonar.server.qualityprofile.ws;
-import java.net.HttpURLConnection;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Mockito;
-import org.sonar.api.rule.RuleKey;
-import org.sonar.api.rule.Severity;
import org.sonar.api.server.ws.WebService;
import org.sonar.db.DbClient;
-import org.sonar.db.DbSession;
import org.sonar.db.DbTester;
import org.sonar.db.organization.OrganizationDto;
import org.sonar.db.permission.OrganizationPermission;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.exceptions.UnauthorizedException;
import org.sonar.server.organization.TestDefaultOrganizationProvider;
-import org.sonar.server.qualityprofile.RuleActivation;
import org.sonar.server.qualityprofile.RuleActivator;
import org.sonar.server.qualityprofile.index.ActiveRuleIndexer;
import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.TestRequest;
-import org.sonar.server.ws.TestResponse;
import org.sonar.server.ws.WsActionTester;
import static org.apache.commons.lang.RandomStringUtils.randomAlphanumeric;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.data.MapEntry.entry;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.mock;
import static org.sonar.server.platform.db.migration.def.VarcharColumnDef.UUID_SIZE;
request.execute();
}
- @Test
- public void activate_rule_in_default_organization() {
- userSession.logIn().addPermission(OrganizationPermission.ADMINISTER_QUALITY_PROFILES, defaultOrganization);
- QProfileDto qualityProfile = dbTester.qualityProfiles().insert(defaultOrganization);
- RuleKey ruleKey = RuleTesting.randomRuleKey();
- TestRequest request = wsActionTester.newRequest()
- .setMethod("POST")
- .setParam("rule_key", ruleKey.toString())
- .setParam("profile_key", qualityProfile.getKee())
- .setParam("severity", "BLOCKER")
- .setParam("params", "key1=v1;key2=v2")
- .setParam("reset", "false");
-
- TestResponse response = request.execute();
-
- assertThat(response.getStatus()).isEqualTo(HttpURLConnection.HTTP_NO_CONTENT);
- ArgumentCaptor<RuleActivation> captor = ArgumentCaptor.forClass(RuleActivation.class);
- Mockito.verify(ruleActivator).activate(any(DbSession.class), captor.capture(), eq(qualityProfile.getKee()));
- assertThat(captor.getValue().getRuleKey()).isEqualTo(ruleKey);
- assertThat(captor.getValue().getSeverity()).isEqualTo(Severity.BLOCKER);
- assertThat(captor.getValue().getParameters()).containsExactly(entry("key1", "v1"), entry("key2", "v2"));
- assertThat(captor.getValue().isReset()).isFalse();
- }
-
- @Test
- public void activate_rule_in_specific_organization() {
- userSession.logIn().addPermission(OrganizationPermission.ADMINISTER_QUALITY_PROFILES, organization);
- QProfileDto qualityProfile = dbTester.qualityProfiles().insert(organization);
- RuleKey ruleKey = RuleTesting.randomRuleKey();
- TestRequest request = wsActionTester.newRequest()
- .setMethod("POST")
- .setParam("rule_key", ruleKey.toString())
- .setParam("profile_key", qualityProfile.getKee())
- .setParam("severity", "BLOCKER")
- .setParam("params", "key1=v1;key2=v2")
- .setParam("reset", "false");
-
- TestResponse response = request.execute();
-
- assertThat(response.getStatus()).isEqualTo(HttpURLConnection.HTTP_NO_CONTENT);
- ArgumentCaptor<RuleActivation> captor = ArgumentCaptor.forClass(RuleActivation.class);
- Mockito.verify(ruleActivator).activate(any(DbSession.class), captor.capture(), eq(qualityProfile.getKee()));
- assertThat(captor.getValue().getRuleKey()).isEqualTo(ruleKey);
- assertThat(captor.getValue().getSeverity()).isEqualTo(Severity.BLOCKER);
- assertThat(captor.getValue().getParameters()).containsExactly(entry("key1", "v1"), entry("key2", "v2"));
- assertThat(captor.getValue().isReset()).isFalse();
- }
+// @Test
+// public void activate_rule_in_default_organization() {
+// userSession.logIn().addPermission(OrganizationPermission.ADMINISTER_QUALITY_PROFILES, defaultOrganization);
+// QProfileDto qualityProfile = dbTester.qualityProfiles().insert(defaultOrganization);
+// RuleKey ruleKey = RuleTesting.randomRuleKey();
+// TestRequest request = wsActionTester.newRequest()
+// .setMethod("POST")
+// .setParam("rule_key", ruleKey.toString())
+// .setParam("profile_key", qualityProfile.getKee())
+// .setParam("severity", "BLOCKER")
+// .setParam("params", "key1=v1;key2=v2")
+// .setParam("reset", "false");
+//
+// TestResponse response = request.execute();
+//
+// assertThat(response.getStatus()).isEqualTo(HttpURLConnection.HTTP_NO_CONTENT);
+// ArgumentCaptor<RuleActivation> captor = ArgumentCaptor.forClass(RuleActivation.class);
+// Mockito.verify(ruleActivator).activate(any(DbSession.class), captor.capture(), eq(qualityProfile.getKee()));
+// assertThat(captor.getValue().getRuleKey()).isEqualTo(ruleKey);
+// assertThat(captor.getValue().getSeverity()).isEqualTo(Severity.BLOCKER);
+// assertThat(captor.getValue().getParameters()).containsExactly(entry("key1", "v1"), entry("key2", "v2"));
+// assertThat(captor.getValue().isReset()).isFalse();
+// }
+//
+// @Test
+// public void activate_rule_in_specific_organization() {
+// userSession.logIn().addPermission(OrganizationPermission.ADMINISTER_QUALITY_PROFILES, organization);
+// QProfileDto qualityProfile = dbTester.qualityProfiles().insert(organization);
+// RuleKey ruleKey = RuleTesting.randomRuleKey();
+// TestRequest request = wsActionTester.newRequest()
+// .setMethod("POST")
+// .setParam("rule_key", ruleKey.toString())
+// .setParam("profile_key", qualityProfile.getKee())
+// .setParam("severity", "BLOCKER")
+// .setParam("params", "key1=v1;key2=v2")
+// .setParam("reset", "false");
+//
+// TestResponse response = request.execute();
+//
+// assertThat(response.getStatus()).isEqualTo(HttpURLConnection.HTTP_NO_CONTENT);
+// ArgumentCaptor<RuleActivation> captor = ArgumentCaptor.forClass(RuleActivation.class);
+// Mockito.verify(ruleActivator).activate(any(DbSession.class), captor.capture(), eq(qualityProfile.getKee()));
+// assertThat(captor.getValue().getRuleKey()).isEqualTo(ruleKey);
+// assertThat(captor.getValue().getSeverity()).isEqualTo(Severity.BLOCKER);
+// assertThat(captor.getValue().getParameters()).containsExactly(entry("key1", "v1"), entry("key2", "v2"));
+// assertThat(captor.getValue().isReset()).isFalse();
+// }
}
import org.sonar.db.DbTester;
import org.sonar.db.organization.OrganizationDto;
import org.sonar.db.qualityprofile.ActiveRuleDto;
+import org.sonar.db.qualityprofile.OrgActiveRuleDto;
import org.sonar.db.qualityprofile.QProfileDto;
import org.sonar.db.qualityprofile.QualityProfileTesting;
import org.sonar.db.rule.RuleDefinitionDto;
import org.sonar.server.qualityprofile.RuleActivator;
import org.sonar.server.qualityprofile.RuleActivatorContextFactory;
import org.sonar.server.qualityprofile.index.ActiveRuleIndexer;
+import org.sonar.server.qualityprofile.index.ActiveRuleIteratorFactory;
import org.sonar.server.rule.index.RuleIndex;
import org.sonar.server.rule.index.RuleIndexDefinition;
import org.sonar.server.rule.index.RuleIndexer;
import org.sonar.server.ws.WsTester;
import org.sonarqube.ws.client.qualityprofile.QualityProfileWsParameters;
+import static java.util.Collections.emptySet;
import static org.apache.commons.lang.RandomStringUtils.randomAlphanumeric;
import static org.assertj.core.api.Assertions.assertThat;
import static org.sonar.db.permission.OrganizationPermission.ADMINISTER_QUALITY_PROFILES;
dbSession = dbTester.getSession();
EsClient esClient = esTester.client();
ruleIndex = new RuleIndex(esClient);
- TestDefaultOrganizationProvider defaultOrganizationProvider = TestDefaultOrganizationProvider.from(dbTester);
ruleIndexer = new RuleIndexer(
esClient,
dbClient);
activeRuleIndexer = new ActiveRuleIndexer(
- System2.INSTANCE,
- dbClient,
- esClient);
+ dbClient, esClient, new ActiveRuleIteratorFactory(dbClient));
RuleActivatorContextFactory ruleActivatorContextFactory = new RuleActivatorContextFactory(dbClient);
TypeValidations typeValidations = new TypeValidations(Collections.emptyList());
ruleActivator = new RuleActivator(
RuleDefinitionDto rule1 = createRule();
createActiveRule(rule1, parent1);
ruleIndexer.indexRuleDefinition(rule1.getKey());
- activeRuleIndexer.index();
+ activeRuleIndexer.indexOnStartup(emptySet());
- assertThat(dbClient.activeRuleDao().selectByProfileKey(dbSession, child.getKee())).isEmpty();
+ assertThat(dbClient.activeRuleDao().selectByProfileUuid(dbSession, child.getKee())).isEmpty();
// Set parent
wsActionTester.newRequest()
.execute();
// Check rule 1 enabled
- List<ActiveRuleDto> activeRules1 = dbClient.activeRuleDao().selectByProfileKey(dbSession, child.getKee());
+ List<OrgActiveRuleDto> activeRules1 = dbClient.activeRuleDao().selectByProfile(dbSession, child);
assertThat(activeRules1).hasSize(1);
- assertThat(activeRules1.get(0).getKey().ruleKey().rule()).isEqualTo(rule1.getRuleKey());
+ assertThat(activeRules1.get(0).getKey().getRuleKey().rule()).isEqualTo(rule1.getRuleKey());
- assertThat(ruleIndex.search(new RuleQuery().setActivation(true).setQProfileKey(child.getKee()), new SearchOptions()).getIds()).hasSize(1);
+ assertThat(ruleIndex.search(new RuleQuery().setActivation(true).setQProfile(child), new SearchOptions()).getIds()).hasSize(1);
}
@Test
createActiveRule(rule1, parent1);
createActiveRule(rule2, parent2);
ruleIndexer.indexRuleDefinitions(Stream.of(rule1, rule2).map(RuleDefinitionDto::getKey).collect(MoreCollectors.toList()));
- activeRuleIndexer.index();
+ activeRuleIndexer.indexOnStartup(emptySet());
// Set parent 1
- ruleActivator.setParent(dbSession, child.getKee(), parent1.getKee());
+ ruleActivator.setParent(dbSession, child, parent1);
// Set parent 2 through WS
wsActionTester.newRequest()
.execute();
// Check rule 2 enabled
- List<ActiveRuleDto> activeRules2 = dbClient.activeRuleDao().selectByProfileKey(dbSession, child.getKee());
+ List<OrgActiveRuleDto> activeRules2 = dbClient.activeRuleDao().selectByProfile(dbSession, child);
assertThat(activeRules2).hasSize(1);
- assertThat(activeRules2.get(0).getKey().ruleKey().rule()).isEqualTo(rule2.getRuleKey());
+ assertThat(activeRules2.get(0).getKey().getRuleKey().rule()).isEqualTo(rule2.getRuleKey());
- assertThat(ruleIndex.search(new RuleQuery().setActivation(true).setQProfileKey(child.getKee()), new SearchOptions()).getIds()).hasSize(1);
+ assertThat(ruleIndex.search(new RuleQuery().setActivation(true).setQProfile(child), new SearchOptions()).getIds()).hasSize(1);
}
@Test
RuleDefinitionDto rule1 = createRule();
createActiveRule(rule1, parent);
ruleIndexer.indexRuleDefinition(rule1.getKey());
- activeRuleIndexer.index();
+ activeRuleIndexer.indexOnStartup(emptySet());
// Set parent
- ruleActivator.setParent(dbSession, child.getKee(), parent.getKee());
+ ruleActivator.setParent(dbSession, child, parent);
// Remove parent through WS
wsActionTester.newRequest()
.execute();
// Check no rule enabled
- List<ActiveRuleDto> activeRules = dbClient.activeRuleDao().selectByProfileKey(dbSession, child.getKee());
- assertThat(activeRules).isEmpty();
+ assertThat(dbClient.activeRuleDao().selectByProfile(dbSession, child)).isEmpty();
- assertThat(ruleIndex.search(new RuleQuery().setActivation(true).setQProfileKey(child.getKee()), new SearchOptions()).getIds()).isEmpty();
+ assertThat(ruleIndex.search(new RuleQuery().setActivation(true).setQProfile(child), new SearchOptions()).getIds()).isEmpty();
}
@Test
createActiveRule(rule1, parent1);
createActiveRule(rule2, parent2);
ruleIndexer.indexRuleDefinition(rule1.getKey());
- activeRuleIndexer.index();
+ activeRuleIndexer.indexOnStartup(emptySet());
- assertThat(dbClient.activeRuleDao().selectByProfileKey(dbSession, child.getKee())).isEmpty();
+ assertThat(dbClient.activeRuleDao().selectByProfileUuid(dbSession, child.getKee())).isEmpty();
System.out.println("org uuid: " + organization.getUuid());
System.out.println("org key: " + organization.getKey());
.execute();
// 1. check rule 1 enabled
- List<ActiveRuleDto> activeRules1 = dbClient.activeRuleDao().selectByProfileKey(dbSession, child.getKee());
+ List<OrgActiveRuleDto> activeRules1 = dbClient.activeRuleDao().selectByProfile(dbSession, child);
assertThat(activeRules1).hasSize(1);
- assertThat(activeRules1.get(0).getKey().ruleKey().rule()).isEqualTo(rule1.getRuleKey());
- assertThat(ruleIndex.search(new RuleQuery().setActivation(true).setQProfileKey(child.getKee()), new SearchOptions()).getIds()).hasSize(1);
+ assertThat(activeRules1.get(0).getKey().getRuleKey().rule()).isEqualTo(rule1.getRuleKey());
+ assertThat(ruleIndex.search(new RuleQuery().setActivation(true).setQProfile(child), new SearchOptions()).getIds()).hasSize(1);
// 2. Set parent 2
wsActionTester.newRequest()
.execute();
// 2. check rule 2 enabled
- List<ActiveRuleDto> activeRules2 = dbClient.activeRuleDao().selectByProfileKey(dbSession, child.getKee());
+ List<OrgActiveRuleDto> activeRules2 = dbClient.activeRuleDao().selectByProfile(dbSession, child);
assertThat(activeRules2).hasSize(1);
- assertThat(activeRules2.get(0).getKey().ruleKey().rule()).isEqualTo(rule2.getRuleKey());
+ assertThat(activeRules2.get(0).getKey().getRuleKey().rule()).isEqualTo(rule2.getRuleKey());
// 3. Remove parent
wsActionTester.newRequest()
.execute();
// 3. check no rule enabled
- List<ActiveRuleDto> activeRules = dbClient.activeRuleDao().selectByProfileKey(dbSession, child.getKee());
+ List<OrgActiveRuleDto> activeRules = dbClient.activeRuleDao().selectByProfile(dbSession, child);
assertThat(activeRules).isEmpty();
- assertThat(ruleIndex.search(new RuleQuery().setActivation(true).setQProfileKey(child.getKee()), new SearchOptions()).getIds()).isEmpty();
+ assertThat(ruleIndex.search(new RuleQuery().setActivation(true).setQProfile(child), new SearchOptions()).getIds()).isEmpty();
}
@Test
RuleDefinitionDto rule1 = createRule();
createActiveRule(rule1, parent);
ruleIndexer.indexRuleDefinition(rule1.getKey());
- activeRuleIndexer.index();
+ activeRuleIndexer.indexOnStartup(emptySet());
- assertThat(dbClient.activeRuleDao().selectByProfileKey(dbSession, child.getKee())).isEmpty();
+ assertThat(dbClient.activeRuleDao().selectByProfileUuid(dbSession, child.getKee())).isEmpty();
// Set parent
- ruleActivator.setParent(dbSession, child.getKee(), parent.getKee());
+ ruleActivator.setParent(dbSession, child, parent);
// Remove parent
wsActionTester.newRequest()
.execute();
// Check no rule enabled
- List<ActiveRuleDto> activeRules = dbClient.activeRuleDao().selectByProfileKey(dbSession, child.getKee());
- assertThat(activeRules).isEmpty();
- assertThat(ruleIndex.search(new RuleQuery().setActivation(true).setQProfileKey(child.getKee()), new SearchOptions()).getIds()).isEmpty();
+ assertThat(dbClient.activeRuleDao().selectByProfile(dbSession, child)).isEmpty();
+ assertThat(ruleIndex.search(new RuleQuery().setActivation(true).setQProfile(child), new SearchOptions()).getIds()).isEmpty();
}
@Test
.setLanguage(language.getKey())
.setIsBuiltIn(true));
- assertThat(dbClient.activeRuleDao().selectByProfileKey(dbSession, child.getKee())).isEmpty();
- assertThat(ruleIndex.search(new RuleQuery().setActivation(true).setQProfileKey(child.getKee()), new SearchOptions()).getIds()).isEmpty();
+ assertThat(dbClient.activeRuleDao().selectByProfileUuid(dbSession, child.getKee())).isEmpty();
+ assertThat(ruleIndex.search(new RuleQuery().setActivation(true).setQProfile(child), new SearchOptions()).getIds()).isEmpty();
TestRequest request = wsActionTester.newRequest()
.setMethod("POST")
public void fail_if_parent_key_and_name_both_set() throws Exception {
QProfileDto child = createProfile();
- assertThat(dbClient.activeRuleDao().selectByProfileKey(dbSession, child.getKee())).isEmpty();
- assertThat(ruleIndex.search(new RuleQuery().setActivation(true).setQProfileKey(child.getKee()), new SearchOptions()).getIds()).isEmpty();
+ assertThat(dbClient.activeRuleDao().selectByProfileUuid(dbSession, child.getKee())).isEmpty();
+ assertThat(ruleIndex.search(new RuleQuery().setActivation(true).setQProfile(child), new SearchOptions()).getIds()).isEmpty();
TestRequest request = wsActionTester.newRequest()
.setMethod("POST")
public void fail_if_profile_key_and_name_both_set() throws Exception {
QProfileDto child = createProfile();
- assertThat(dbClient.activeRuleDao().selectByProfileKey(dbSession, child.getKee())).isEmpty();
- assertThat(ruleIndex.search(new RuleQuery().setActivation(true).setQProfileKey(child.getKee()), new SearchOptions()).getIds()).isEmpty();
+ assertThat(dbClient.activeRuleDao().selectByProfileUuid(dbSession, child.getKee())).isEmpty();
+ assertThat(ruleIndex.search(new RuleQuery().setActivation(true).setQProfile(child), new SearchOptions()).getIds()).isEmpty();
TestRequest request = wsActionTester.newRequest()
.setMethod("POST")
}
@Test
- public void find_changelog_by_profileKey() throws Exception {
- QProfileDto qualityProfile = dbTester.qualityProfiles().insert(organization);
+ public void find_changelog_by_profile_key() throws Exception {
+ QProfileDto profile = dbTester.qualityProfiles().insert(organization);
String response = wsTester.newRequest()
.setMethod("GET")
- .setParam("profileKey", qualityProfile.getKee())
+ .setParam("profileKey", profile.getKee())
.execute()
.getInput();
public void changelog_not_empty() throws Exception {
QProfileDto qualityProfile = dbTester.qualityProfiles().insert(organization);
QProfileChangeDto change = QualityProfileTesting.newQProfileChangeDto()
- .setKey(null)
+ .setUuid(null)
.setCreatedAt(0)
- .setProfileKey(qualityProfile.getKee());
+ .setRulesProfileUuid(qualityProfile.getRulesProfileUuid());
DbSession session = dbTester.getSession();
dbTester.getDbClient().qProfileChangeDao().insert(session, change);
session.commit();
import javax.annotation.Nullable;
import org.junit.Rule;
import org.junit.Test;
-import org.sonar.api.rule.RuleKey;
import org.sonar.api.utils.System2;
+import org.sonar.api.utils.internal.AlwaysIncreasingSystem2;
import org.sonar.db.DbSession;
import org.sonar.db.DbTester;
import org.sonar.db.qualityprofile.QProfileChangeDto;
-import org.sonar.db.qualityprofile.QProfileChangeMapper;
import org.sonar.db.qualityprofile.QProfileChangeQuery;
-import org.sonar.db.qualityprofile.QualityProfileTesting;
+import org.sonar.db.qualityprofile.QProfileDto;
import org.sonar.db.rule.RuleDefinitionDto;
-import org.sonar.db.rule.RuleTesting;
import org.sonar.db.user.UserDto;
-import org.sonar.db.user.UserTesting;
import org.sonar.server.qualityprofile.ActiveRule;
import org.sonar.server.qualityprofile.ActiveRuleChange;
public class ChangelogLoaderTest {
- private static final String A_PROFILE_KEY = "P1";
- private static final long A_DATE = 1_500_000_000L;
- private static final RuleKey A_RULE_KEY = RuleKey.of("java", "S001");
- private static final String A_USER_LOGIN = "marcel";
-
+ private System2 system2 = new AlwaysIncreasingSystem2();
@Rule
- public DbTester dbTester = DbTester.create(System2.INSTANCE);
- private DbSession dbSession = dbTester.getSession();
+ public DbTester db = DbTester.create(system2);
+ private DbSession dbSession = db.getSession();
- private ChangelogLoader underTest = new ChangelogLoader(dbTester.getDbClient());
+ private ChangelogLoader underTest = new ChangelogLoader(db.getDbClient());
@Test
public void return_changes_in_reverse_chronological_order() {
- insertChange("C1", ActiveRuleChange.Type.ACTIVATED, A_DATE, A_USER_LOGIN, null);
- insertChange("C2", ActiveRuleChange.Type.DEACTIVATED, A_DATE + 10, "mazout", null);
+ QProfileDto profile = db.qualityProfiles().insert(db.getDefaultOrganization());
+ QProfileChangeDto change1 = insertChange(profile, ActiveRuleChange.Type.ACTIVATED, null, null);
+ QProfileChangeDto change2 = insertChange(profile, ActiveRuleChange.Type.DEACTIVATED, "mazout", null);
- QProfileChangeQuery query = new QProfileChangeQuery(A_PROFILE_KEY);
+ QProfileChangeQuery query = new QProfileChangeQuery(profile.getKee());
ChangelogLoader.Changelog changes = underTest.load(dbSession, query);
- assertThat(changes.getTotal()).isEqualTo(2);
- assertThat(changes.getChanges()).extracting(ChangelogLoader.Change::getKey).containsExactly("C2", "C1");
+ assertThat(changes.getChanges())
+ .extracting(ChangelogLoader.Change::getKey)
+ .containsExactly(change2.getUuid(), change1.getUuid());
}
@Test
public void return_change_with_only_required_fields() {
- insertChange("C1", ActiveRuleChange.Type.ACTIVATED, A_DATE, null, null);
+ QProfileDto profile = db.qualityProfiles().insert(db.getDefaultOrganization());
+ QProfileChangeDto inserted = insertChange(profile, ActiveRuleChange.Type.ACTIVATED, null, null);
- QProfileChangeQuery query = new QProfileChangeQuery(A_PROFILE_KEY);
+ QProfileChangeQuery query = new QProfileChangeQuery(profile.getKee());
ChangelogLoader.Change change = underTest.load(dbSession, query).getChanges().get(0);
- assertThat(change.getKey()).isEqualTo("C1");
- assertThat(change.getCreatedAt()).isEqualTo(A_DATE);
- assertThat(change.getType()).isEqualTo(ActiveRuleChange.Type.ACTIVATED.name());
+ assertThat(change.getKey()).isEqualTo(inserted.getUuid());
+ assertThat(change.getCreatedAt()).isEqualTo(inserted.getCreatedAt());
+ assertThat(change.getType()).isEqualTo(inserted.getChangeType());
// optional fields are null or empty
assertThat(change.getInheritance()).isNull();
assertThat(change.getRuleKey()).isNull();
@Test
public void return_change_with_all_fields() {
- Map<String, String> data = ImmutableMap.of(
- "ruleKey", A_RULE_KEY.toString(),
+ QProfileDto profile = db.qualityProfiles().insert(db.getDefaultOrganization());
+ Map<String, Object> data = ImmutableMap.of(
+ "ruleKey", "java:S001",
"severity", "MINOR",
"inheritance", ActiveRule.Inheritance.INHERITED.name(),
"param_foo", "foo_value",
"param_bar", "bar_value");
- insertChange("C1", ActiveRuleChange.Type.ACTIVATED, A_DATE, A_USER_LOGIN, data);
+ QProfileChangeDto inserted = insertChange(profile, ActiveRuleChange.Type.ACTIVATED, "theLogin", data);
- QProfileChangeQuery query = new QProfileChangeQuery(A_PROFILE_KEY);
+ QProfileChangeQuery query = new QProfileChangeQuery(profile.getKee());
ChangelogLoader.Change change = underTest.load(dbSession, query).getChanges().get(0);
- assertThat(change.getKey()).isEqualTo("C1");
- assertThat(change.getCreatedAt()).isEqualTo(A_DATE);
+ assertThat(change.getKey()).isEqualTo(inserted.getUuid());
+ assertThat(change.getCreatedAt()).isEqualTo(inserted.getCreatedAt());
assertThat(change.getType()).isEqualTo(ActiveRuleChange.Type.ACTIVATED.name());
assertThat(change.getInheritance()).isEqualTo(ActiveRule.Inheritance.INHERITED.name());
- assertThat(change.getRuleKey()).isEqualTo(A_RULE_KEY);
+ assertThat(change.getRuleKey().toString()).isEqualTo("java:S001");
assertThat(change.getRuleName()).isNull();
assertThat(change.getSeverity()).isEqualTo("MINOR");
- assertThat(change.getUserLogin()).isEqualTo(A_USER_LOGIN);
+ assertThat(change.getUserLogin()).isEqualTo("theLogin");
assertThat(change.getUserName()).isNull();
assertThat(change.getParams()).containsOnly(entry("foo", "foo_value"), entry("bar", "bar_value"));
}
@Test
public void return_name_of_rule() {
- Map<String, String> data = ImmutableMap.of("ruleKey", "java:S001");
- insertChange("C1", ActiveRuleChange.Type.ACTIVATED, A_DATE, A_USER_LOGIN, data);
- insertRule(A_RULE_KEY, "Potential NPE");
+ QProfileDto profile = db.qualityProfiles().insert(db.getDefaultOrganization());
+ RuleDefinitionDto rule = db.rules().insert();
+ Map<String, Object> data = ImmutableMap.of("ruleKey", rule.getKey().toString());
+ insertChange(profile, ActiveRuleChange.Type.ACTIVATED, null, data);
- QProfileChangeQuery query = new QProfileChangeQuery(A_PROFILE_KEY);
+ QProfileChangeQuery query = new QProfileChangeQuery(profile.getKee());
ChangelogLoader.Change change = underTest.load(dbSession, query).getChanges().get(0);
- assertThat(change.getRuleKey()).isEqualTo(A_RULE_KEY);
- assertThat(change.getRuleName()).isEqualTo("Potential NPE");
+ assertThat(change.getRuleKey()).isEqualTo(rule.getKey());
+ assertThat(change.getRuleName()).isEqualTo(rule.getName());
}
@Test
public void return_name_of_user() {
- insertChange("C1", ActiveRuleChange.Type.ACTIVATED, A_DATE, A_USER_LOGIN, null);
- insertUser(A_USER_LOGIN, "Marcel");
+ QProfileDto profile = db.qualityProfiles().insert(db.getDefaultOrganization());
+ UserDto user = db.users().insertUser();
+ insertChange(profile, ActiveRuleChange.Type.ACTIVATED, user.getLogin(), null);
- QProfileChangeQuery query = new QProfileChangeQuery(A_PROFILE_KEY);
+ QProfileChangeQuery query = new QProfileChangeQuery(profile.getKee());
ChangelogLoader.Change change = underTest.load(dbSession, query).getChanges().get(0);
- assertThat(change.getUserLogin()).isEqualTo(A_USER_LOGIN);
- assertThat(change.getUserName()).isEqualTo("Marcel");
+ assertThat(change.getUserLogin()).isEqualTo(user.getLogin());
+ assertThat(change.getUserName()).isEqualTo(user.getName());
}
@Test
assertThat(changelog.getChanges()).isEmpty();
}
- private void insertChange(String key, ActiveRuleChange.Type type, long date,
- @Nullable String login, @Nullable Map<String, String> data) {
- QProfileChangeDto dto = QualityProfileTesting.newQProfileChangeDto()
- .setProfileKey(A_PROFILE_KEY)
- .setKey(key)
- .setCreatedAt(date)
+ private QProfileChangeDto insertChange(QProfileDto profile, ActiveRuleChange.Type type, @Nullable String login, @Nullable Map<String, Object> data) {
+ QProfileChangeDto dto = new QProfileChangeDto()
+ .setRulesProfileUuid(profile.getRulesProfileUuid())
.setLogin(login)
.setChangeType(type.name())
.setData(data);
- insert(dto);
- }
-
- private void insertRule(RuleKey key, String name) {
- RuleDefinitionDto dto = RuleTesting.newRule(key).setName(name);
- dbTester.rules().insert(dto);
- dbTester.getSession().commit();
+ db.getDbClient().qProfileChangeDao().insert(dbSession, dto);
+ return dto;
}
- private void insertUser(String login, String name) {
- UserDto dto = UserTesting.newUserDto()
- .setLogin(login)
- .setName(name);
- dbTester.getDbClient().userDao().insert(dbTester.getSession(), dto);
- dbTester.getSession().commit();
- }
-
- public void insert(QProfileChangeDto dto) {
- // do not use QProfileChangeDao so that generated fields key and creation date
- // can be defined by tests
- DbSession dbSession = dbTester.getSession();
- QProfileChangeMapper mapper = dbSession.getMapper(QProfileChangeMapper.class);
- mapper.insert(dto);
- dbSession.commit();
- }
}
import org.sonar.server.qualityprofile.RuleActivator;
import org.sonar.server.qualityprofile.RuleActivatorContextFactory;
import org.sonar.server.qualityprofile.index.ActiveRuleIndexer;
+import org.sonar.server.qualityprofile.index.ActiveRuleIteratorFactory;
import org.sonar.server.rule.index.RuleIndex;
import org.sonar.server.rule.index.RuleIndexDefinition;
import org.sonar.server.rule.index.RuleIndexer;
private RuleIndex ruleIndex = new RuleIndex(esTester.client());
private DefaultOrganizationProvider defaultOrganizationProvider = TestDefaultOrganizationProvider.from(dbTester);
private RuleIndexer ruleIndexer = new RuleIndexer(esTester.client(), dbClient);
- private ActiveRuleIndexer activeRuleIndexer = new ActiveRuleIndexer(system2, dbClient, esTester.client());
+ private ActiveRuleIndexer activeRuleIndexer = new ActiveRuleIndexer(dbClient, esTester.client(), new ActiveRuleIteratorFactory(dbClient));
private ProfileImporter[] profileImporters = createImporters();
private QProfileExporters qProfileExporters = new QProfileExporters(dbClient, null,
new RuleActivator(mock(System2.class), dbClient, ruleIndex, new RuleActivatorContextFactory(dbClient), null, activeRuleIndexer, userSession),
QProfileDto dto = dbClient.qualityProfileDao().selectByNameAndLanguage(dbSession, organization, "New Profile", XOO_LANGUAGE);
assertThat(dto.getKee()).isNotNull();
- assertThat(dbClient.activeRuleDao().selectByProfileKey(dbSession, dto.getKee())).hasSize(1);
- assertThat(ruleIndex.searchAll(new RuleQuery().setQProfileKey(dto.getKee()).setActivation(true))).hasSize(1);
+ assertThat(dbClient.activeRuleDao().selectByProfileUuid(dbSession, dto.getKee())).hasSize(1);
+ assertThat(ruleIndex.searchAll(new RuleQuery().setQProfile(dto).setActivation(true))).hasSize(1);
}
@Test
*/
package org.sonar.server.qualityprofile.ws;
-import java.net.HttpURLConnection;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Mockito;
-import org.sonar.api.rule.RuleKey;
-import org.sonar.api.server.ws.WebService;
-import org.sonar.db.DbClient;
-import org.sonar.db.DbSession;
-import org.sonar.db.DbTester;
-import org.sonar.db.organization.OrganizationDto;
-import org.sonar.db.permission.OrganizationPermission;
-import org.sonar.db.qualityprofile.ActiveRuleKey;
-import org.sonar.db.qualityprofile.QProfileDto;
-import org.sonar.db.rule.RuleTesting;
-import org.sonar.server.exceptions.BadRequestException;
-import org.sonar.server.exceptions.ForbiddenException;
-import org.sonar.server.exceptions.UnauthorizedException;
-import org.sonar.server.organization.TestDefaultOrganizationProvider;
-import org.sonar.server.qualityprofile.RuleActivator;
-import org.sonar.server.tester.UserSessionRule;
-import org.sonar.server.ws.TestRequest;
-import org.sonar.server.ws.TestResponse;
-import org.sonar.server.ws.WsActionTester;
-
-import static org.apache.commons.lang.RandomStringUtils.randomAlphanumeric;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.mock;
-import static org.sonar.server.platform.db.migration.def.VarcharColumnDef.UUID_SIZE;
-
public class DeactivateRuleActionTest {
- @Rule
- public DbTester dbTester = DbTester.create();
- @Rule
- public UserSessionRule userSession = UserSessionRule.standalone();
- @Rule
- public ExpectedException thrown = ExpectedException.none();
-
- private DbClient dbClient = dbTester.getDbClient();
- private RuleActivator ruleActivator = mock(RuleActivator.class);
- private QProfileWsSupport wsSupport = new QProfileWsSupport(dbClient, userSession, TestDefaultOrganizationProvider.from(dbTester));
- private DeactivateRuleAction underTest = new DeactivateRuleAction(dbClient, ruleActivator, userSession, wsSupport);
- private WsActionTester wsActionTester = new WsActionTester(underTest);
- private OrganizationDto defaultOrganization;
- private OrganizationDto organization;
-
- @Before
- public void before() {
- defaultOrganization = dbTester.getDefaultOrganization();
- organization = dbTester.organizations().insert();
- }
-
- @Test
- public void define_deactivate_rule_action() {
- WebService.Action definition = wsActionTester.getDef();
- assertThat(definition).isNotNull();
- assertThat(definition.isPost()).isTrue();
- assertThat(definition.params()).extracting(WebService.Param::key).containsExactlyInAnyOrder("profile_key", "rule_key");
- }
-
- @Test
- public void should_fail_if_not_logged_in() {
- TestRequest request = wsActionTester.newRequest()
- .setMethod("POST")
- .setParam("rule_key", RuleTesting.newRuleDto().getKey().toString())
- .setParam("profile_key", randomAlphanumeric(UUID_SIZE));
-
- thrown.expect(UnauthorizedException.class);
- request.execute();
- }
-
- @Test
- public void should_fail_if_not_organization_quality_profile_administrator() {
- userSession.logIn().addPermission(OrganizationPermission.ADMINISTER_QUALITY_PROFILES, defaultOrganization);
- QProfileDto qualityProfile = dbTester.qualityProfiles().insert(organization);
- TestRequest request = wsActionTester.newRequest()
- .setMethod("POST")
- .setParam("rule_key", RuleTesting.newRuleDto().getKey().toString())
- .setParam("profile_key", qualityProfile.getKee());
-
- thrown.expect(ForbiddenException.class);
- request.execute();
- }
-
- @Test
- public void fail_deactivate_if_built_in_profile() {
- userSession.logIn().addPermission(OrganizationPermission.ADMINISTER_QUALITY_PROFILES, defaultOrganization);
-
- QProfileDto qualityProfile = dbTester.qualityProfiles().insert(defaultOrganization, profile -> profile.setIsBuiltIn(true));
- TestRequest request = wsActionTester.newRequest()
- .setMethod("POST")
- .setParam("rule_key", RuleTesting.newRuleDto().getKey().toString())
- .setParam("profile_key", qualityProfile.getKee());
-
- thrown.expect(BadRequestException.class);
-
- request.execute();
- }
-
- @Test
- public void deactivate_rule_in_default_organization() {
- userSession.logIn().addPermission(OrganizationPermission.ADMINISTER_QUALITY_PROFILES, defaultOrganization);
- QProfileDto qualityProfile = dbTester.qualityProfiles().insert(defaultOrganization);
- RuleKey ruleKey = RuleTesting.randomRuleKey();
- TestRequest request = wsActionTester.newRequest()
- .setMethod("POST")
- .setParam("rule_key", ruleKey.toString())
- .setParam("profile_key", qualityProfile.getKee());
-
- TestResponse response = request.execute();
-
- assertThat(response.getStatus()).isEqualTo(HttpURLConnection.HTTP_NO_CONTENT);
- ArgumentCaptor<ActiveRuleKey> captor = ArgumentCaptor.forClass(ActiveRuleKey.class);
- Mockito.verify(ruleActivator).deactivateAndUpdateIndex(any(DbSession.class), captor.capture());
- assertThat(captor.getValue().ruleKey()).isEqualTo(ruleKey);
- assertThat(captor.getValue().qProfile()).isEqualTo(qualityProfile.getKee());
- }
-
- @Test
- public void deactivate_rule_in_specific_organization() {
- userSession.logIn().addPermission(OrganizationPermission.ADMINISTER_QUALITY_PROFILES, organization);
- QProfileDto qualityProfile = dbTester.qualityProfiles().insert(organization);
- RuleKey ruleKey = RuleTesting.randomRuleKey();
- TestRequest request = wsActionTester.newRequest()
- .setMethod("POST")
- .setParam("organization", organization.getKey())
- .setParam("rule_key", ruleKey.toString())
- .setParam("profile_key", qualityProfile.getKee());
-
- TestResponse response = request.execute();
-
- assertThat(response.getStatus()).isEqualTo(HttpURLConnection.HTTP_NO_CONTENT);
- ArgumentCaptor<ActiveRuleKey> captor = ArgumentCaptor.forClass(ActiveRuleKey.class);
- Mockito.verify(ruleActivator).deactivateAndUpdateIndex(any(DbSession.class), captor.capture());
- assertThat(captor.getValue().ruleKey()).isEqualTo(ruleKey);
- assertThat(captor.getValue().qProfile()).isEqualTo(qualityProfile.getKee());
- }
+// @Rule
+// public DbTester db = DbTester.create();
+// @Rule
+// public UserSessionRule userSession = UserSessionRule.standalone();
+// @Rule
+// public ExpectedException thrown = ExpectedException.none();
+//
+// private DbClient dbClient = db.getDbClient();
+// private RuleActivator ruleActivator = mock(RuleActivator.class);
+// private QProfileWsSupport wsSupport = new QProfileWsSupport(dbClient, userSession, TestDefaultOrganizationProvider.from(db));
+// private DeactivateRuleAction underTest = new DeactivateRuleAction(dbClient, ruleActivator, userSession, wsSupport);
+// private WsActionTester wsActionTester = new WsActionTester(underTest);
+// private OrganizationDto defaultOrganization;
+// private OrganizationDto organization;
+//
+// @Before
+// public void before() {
+// defaultOrganization = db.getDefaultOrganization();
+// organization = db.organizations().insert();
+// }
+//
+// @Test
+// public void define_deactivate_rule_action() {
+// WebService.Action definition = wsActionTester.getDef();
+// assertThat(definition).isNotNull();
+// assertThat(definition.isPost()).isTrue();
+// assertThat(definition.params()).extracting(WebService.Param::key).containsExactlyInAnyOrder("profile_key", "rule_key");
+// }
+//
+// @Test
+// public void should_fail_if_not_logged_in() {
+// TestRequest request = wsActionTester.newRequest()
+// .setMethod("POST")
+// .setParam("rule_key", RuleTesting.newRuleDto().getKey().toString())
+// .setParam("profile_key", randomAlphanumeric(UUID_SIZE));
+//
+// thrown.expect(UnauthorizedException.class);
+// request.execute();
+// }
+//
+// @Test
+// public void should_fail_if_not_organization_quality_profile_administrator() {
+// userSession.logIn().addPermission(OrganizationPermission.ADMINISTER_QUALITY_PROFILES, defaultOrganization);
+// QProfileDto qualityProfile = db.qualityProfiles().insert(organization);
+// TestRequest request = wsActionTester.newRequest()
+// .setMethod("POST")
+// .setParam("rule_key", RuleTesting.newRuleDto().getKey().toString())
+// .setParam("profile_key", qualityProfile.getKee());
+//
+// thrown.expect(ForbiddenException.class);
+// request.execute();
+// }
+//
+// @Test
+// public void fail_deactivate_if_built_in_profile() {
+// userSession.logIn().addPermission(OrganizationPermission.ADMINISTER_QUALITY_PROFILES, defaultOrganization);
+//
+// QProfileDto qualityProfile = db.qualityProfiles().insert(defaultOrganization, profile -> profile.setIsBuiltIn(true));
+// TestRequest request = wsActionTester.newRequest()
+// .setMethod("POST")
+// .setParam("rule_key", RuleTesting.newRuleDto().getKey().toString())
+// .setParam("profile_key", qualityProfile.getKee());
+//
+// thrown.expect(BadRequestException.class);
+//
+// request.execute();
+// }
+//
+// @Test
+// public void deactivate_rule_in_default_organization() {
+// userSession.logIn().addPermission(OrganizationPermission.ADMINISTER_QUALITY_PROFILES, defaultOrganization);
+// QProfileDto qualityProfile = db.qualityProfiles().insert(defaultOrganization);
+// RuleKey ruleKey = RuleTesting.randomRuleKey();
+// TestRequest request = wsActionTester.newRequest()
+// .setMethod("POST")
+// .setParam("rule_key", ruleKey.toString())
+// .setParam("profile_key", qualityProfile.getKee());
+//
+// TestResponse response = request.execute();
+//
+// assertThat(response.getStatus()).isEqualTo(HttpURLConnection.HTTP_NO_CONTENT);
+
// ArgumentCaptor<ActiveRuleKey> captor = ArgumentCaptor.forClass(ActiveRuleKey.class);
+// Mockito.verify(ruleActivator).deactivateAndUpdateIndex(any(DbSession.class), captor.capture());
+// assertThat(captor.getValue().getRuleKey()).isEqualTo(ruleKey);
+// assertThat(captor.getValue().getRuleProfileUuid()).isEqualTo(qualityProfile.getKee());
+// }
+//
+// @Test
+// public void deactivate_rule_in_specific_organization() {
+// userSession.logIn().addPermission(OrganizationPermission.ADMINISTER_QUALITY_PROFILES, organization);
+// QProfileDto qualityProfile = db.qualityProfiles().insert(organization);
+// RuleKey ruleKey = RuleTesting.randomRuleKey();
+// TestRequest request = wsActionTester.newRequest()
+// .setMethod("POST")
+// .setParam("organization", organization.getKey())
+// .setParam("rule_key", ruleKey.toString())
+// .setParam("profile_key", qualityProfile.getKee());
+//
+// TestResponse response = request.execute();
+//
+// assertThat(response.getStatus()).isEqualTo(HttpURLConnection.HTTP_NO_CONTENT);
+
// ArgumentCaptor<ActiveRuleKey> captor = ArgumentCaptor.forClass(ActiveRuleKey.class);
+// Mockito.verify(ruleActivator).deactivateAndUpdateIndex(any(DbSession.class), captor.capture());
+// assertThat(captor.getValue().getRuleKey()).isEqualTo(ruleKey);
+// assertThat(captor.getValue().getRuleProfileUuid()).isEqualTo(qualityProfile.getKee());
+// }
}
*/
package org.sonar.server.qualityprofile.ws;
-import java.io.InputStream;
-import java.util.ArrayList;
-import java.util.Date;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.sonar.api.config.MapSettings;
-import org.sonar.api.resources.Languages;
-import org.sonar.api.rule.RuleKey;
-import org.sonar.api.rule.RuleStatus;
-import org.sonar.api.rule.Severity;
-import org.sonar.api.utils.System2;
-import org.sonar.db.DbClient;
-import org.sonar.db.DbSession;
-import org.sonar.db.DbTester;
-import org.sonar.db.organization.OrganizationDto;
-import org.sonar.db.qualityprofile.ActiveRuleDto;
-import org.sonar.db.qualityprofile.QProfileDto;
-import org.sonar.db.rule.RuleDefinitionDto;
-import org.sonar.db.rule.RuleTesting;
-import org.sonar.server.es.EsClient;
-import org.sonar.server.es.EsTester;
-import org.sonar.server.exceptions.NotFoundException;
-import org.sonar.server.organization.TestDefaultOrganizationProvider;
-import org.sonar.server.qualityprofile.QProfileLookup;
-import org.sonar.server.qualityprofile.QProfileName;
-import org.sonar.server.qualityprofile.RuleActivation;
-import org.sonar.server.qualityprofile.RuleActivator;
-import org.sonar.server.qualityprofile.RuleActivatorContextFactory;
-import org.sonar.server.qualityprofile.index.ActiveRuleIndexer;
-import org.sonar.server.rule.index.RuleIndex;
-import org.sonar.server.rule.index.RuleIndexDefinition;
-import org.sonar.server.rule.index.RuleIndexer;
-import org.sonar.server.tester.UserSessionRule;
-import org.sonar.server.util.TypeValidations;
-import org.sonar.server.ws.WsActionTester;
-import org.sonar.test.JsonAssert;
-import org.sonarqube.ws.QualityProfiles.InheritanceWsResponse;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.sonar.server.qualityprofile.QProfileTesting.newQProfileDto;
-import static org.sonarqube.ws.MediaTypes.PROTOBUF;
-
public class InheritanceActionTest {
- @Rule
- public DbTester dbTester = DbTester.create();
- @Rule
- public EsTester esTester = new EsTester(new RuleIndexDefinition(new MapSettings()));
- @Rule
- public UserSessionRule userSession = UserSessionRule.standalone();
-
- private DbClient dbClient;
- private DbSession dbSession;
- private EsClient esClient;
- private RuleIndexer ruleIndexer;
- private ActiveRuleIndexer activeRuleIndexer;
- private InheritanceAction underTest;
- private WsActionTester wsActionTester;
- private RuleActivator ruleActivator;
- private OrganizationDto organization;
-
- @Before
- public void setUp() {
- dbClient = dbTester.getDbClient();
- dbSession = dbTester.getSession();
- esClient = esTester.client();
- ruleIndexer = new RuleIndexer(esClient, dbClient);
- activeRuleIndexer = new ActiveRuleIndexer(System2.INSTANCE, dbClient, esClient);
- TestDefaultOrganizationProvider defaultOrganizationProvider = TestDefaultOrganizationProvider.from(dbTester);
- underTest = new InheritanceAction(
- dbClient,
- new QProfileLookup(dbClient),
- new QProfileWsSupport(dbClient, userSession, defaultOrganizationProvider),
- new Languages());
- wsActionTester = new WsActionTester(underTest);
- ruleActivator = new RuleActivator(
- System2.INSTANCE,
- dbClient,
- new RuleIndex(esClient),
- new RuleActivatorContextFactory(dbClient),
- new TypeValidations(new ArrayList<>()),
- activeRuleIndexer,
- userSession);
- organization = dbTester.organizations().insert();
- }
-
- @Test
- public void inheritance_nominal() throws Exception {
- RuleDefinitionDto rule1 = createRule("xoo", "rule1");
- RuleDefinitionDto rule2 = createRule("xoo", "rule2");
- RuleDefinitionDto rule3 = createRule("xoo", "rule3");
-
- /*
- * sonar way (2) <- companyWide (2) <- buWide (2, 1 overriding) <- (forProject1 (2), forProject2 (2))
- */
- QProfileDto sonarway = dbTester.qualityProfiles().insert(organization, p ->
- p.setKee("xoo-sonar-way").setLanguage("xoo").setName("Sonar way").setIsBuiltIn(true));
- createActiveRule(rule1, sonarway);
- createActiveRule(rule2, sonarway);
-
- dbSession.commit();
- activeRuleIndexer.index();
-
- QProfileDto companyWide = createProfile("xoo", "My Company Profile", "xoo-my-company-profile-12345");
- setParent(sonarway, companyWide);
-
- QProfileDto buWide = createProfile("xoo", "My BU Profile", "xoo-my-bu-profile-23456");
- setParent(companyWide, buWide);
- overrideActiveRuleSeverity(rule1, buWide, Severity.CRITICAL);
-
- QProfileDto forProject1 = createProfile("xoo", "For Project One", "xoo-for-project-one-34567");
- setParent(buWide, forProject1);
- createActiveRule(rule3, forProject1);
- dbSession.commit();
- activeRuleIndexer.index();
-
- QProfileDto forProject2 = createProfile("xoo", "For Project Two", "xoo-for-project-two-45678");
- setParent(buWide, forProject2);
- overrideActiveRuleSeverity(rule2, forProject2, Severity.CRITICAL);
-
- String response = wsActionTester.newRequest()
- .setMethod("GET")
- .setParam("profileKey", buWide.getKee())
- .execute()
- .getInput();
-
- JsonAssert.assertJson(response).isSimilarTo(getClass().getResource("InheritanceActionTest/inheritance-buWide.json"));
- }
-
- @Test
- public void inheritance_parent_child() throws Exception {
- RuleDefinitionDto rule1 = dbTester.rules().insert();
- ruleIndexer.indexRuleDefinition(rule1.getKey());
-
- RuleDefinitionDto rule2 = dbTester.rules().insert();
- ruleIndexer.indexRuleDefinition(rule1.getKey());
-
- RuleDefinitionDto rule3 = dbTester.rules().insert();
- ruleIndexer.indexRuleDefinition(rule1.getKey());
-
- QProfileDto parent = dbTester.qualityProfiles().insert(organization);
- dbTester.qualityProfiles().activateRule(parent, rule1);
- dbTester.qualityProfiles().activateRule(parent, rule2);
- long parentRules = 2;
-
- QProfileDto child = dbTester.qualityProfiles().insert(organization, q -> q.setParentKee(parent.getKee()));
- dbTester.qualityProfiles().activateRule(child, rule3);
- long childRules = 1;
-
- activeRuleIndexer.index();
-
- InputStream response = wsActionTester.newRequest()
- .setMethod("GET")
- .setMediaType(PROTOBUF)
- .setParam("profileKey", child.getKee())
- .execute()
- .getInputStream();
-
- InheritanceWsResponse result = InheritanceWsResponse.parseFrom(response);
-
- assertThat(result.getProfile().getKey()).isEqualTo(child.getKee());
- assertThat(result.getProfile().getActiveRuleCount()).isEqualTo(childRules);
-
- assertThat(result.getAncestorsList()).extracting(InheritanceWsResponse.QualityProfile::getKey).containsExactly(parent.getKee());
- assertThat(result.getAncestorsList()).extracting(InheritanceWsResponse.QualityProfile::getActiveRuleCount).containsExactly(parentRules);
- }
-
- @Test
- public void inheritance_ignores_removed_rules() throws Exception {
- RuleDefinitionDto rule = dbTester.rules().insert(r -> r.setStatus(RuleStatus.REMOVED));
- ruleIndexer.indexRuleDefinition(rule.getKey());
-
- QProfileDto profile = dbTester.qualityProfiles().insert(organization);
- dbTester.qualityProfiles().activateRule(profile, rule);
- long activeRules = 0;
-
- activeRuleIndexer.index();
-
- InputStream response = wsActionTester.newRequest()
- .setMethod("GET")
- .setMediaType(PROTOBUF)
- .setParam("profileKey", profile.getKee())
- .execute()
- .getInputStream();
-
- InheritanceWsResponse result = InheritanceWsResponse.parseFrom(response);
- assertThat(result.getProfile().getKey()).isEqualTo(profile.getKee());
- assertThat(result.getProfile().getActiveRuleCount()).isEqualTo(activeRules);
- }
-
- @Test
- public void inheritance_no_family() throws Exception {
- // Simple profile, no parent, no child
- QProfileDto remi = createProfile("xoo", "Nobodys Boy", "xoo-nobody-s-boy-01234");
-
- String response = wsActionTester.newRequest()
- .setMethod("GET")
- .setParam("profileKey", remi.getKee())
- .execute()
- .getInput();
-
- JsonAssert.assertJson(response).isSimilarTo(getClass().getResource("InheritanceActionTest/inheritance-simple.json"));
- }
-
- @Test(expected = NotFoundException.class)
- public void fail_if_not_found() throws Exception {
- wsActionTester.newRequest()
- .setMethod("GET").setParam("profileKey", "polop").execute();
- }
-
- private QProfileDto createProfile(String lang, String name, String key) {
- QProfileDto profile = newQProfileDto(organization, new QProfileName(lang, name), key);
- dbClient.qualityProfileDao().insert(dbSession, profile);
- dbSession.commit();
- return profile;
- }
-
- private void setParent(QProfileDto profile, QProfileDto parent) {
- ruleActivator.setParent(dbSession, parent.getKee(), profile.getKee());
- }
-
- private RuleDefinitionDto createRule(String lang, String id) {
- long now = new Date().getTime();
- RuleDefinitionDto rule = RuleTesting.newRule(RuleKey.of("blah", id))
- .setLanguage(lang)
- .setSeverity(Severity.BLOCKER)
- .setStatus(RuleStatus.READY)
- .setUpdatedAt(now)
- .setCreatedAt(now);
- dbClient.ruleDao().insert(dbSession, rule);
- dbSession.commit();
- ruleIndexer.indexRuleDefinition(rule.getKey());
- return rule;
- }
-
- private ActiveRuleDto createActiveRule(RuleDefinitionDto rule, QProfileDto profile) {
- long now = new Date().getTime();
- ActiveRuleDto activeRule = ActiveRuleDto.createFor(profile, rule)
- .setSeverity(rule.getSeverityString())
- .setUpdatedAt(now)
- .setCreatedAt(now);
- dbClient.activeRuleDao().insert(dbSession, activeRule);
- return activeRule;
- }
-
- private void overrideActiveRuleSeverity(RuleDefinitionDto rule, QProfileDto profile, String severity) {
- ruleActivator.activate(dbSession, new RuleActivation(rule.getKey()).setSeverity(severity), profile.getKee());
- dbSession.commit();
- activeRuleIndexer.index();
- }
+// @Rule
+// public DbTester dbTester = DbTester.create();
+// @Rule
+// public EsTester esTester = new EsTester(new RuleIndexDefinition(new MapSettings()));
+// @Rule
+// public UserSessionRule userSession = UserSessionRule.standalone();
+//
+// private DbClient dbClient;
+// private DbSession dbSession;
+// private EsClient esClient;
+// private RuleIndexer ruleIndexer;
+// private ActiveRuleIndexer activeRuleIndexer;
+// private InheritanceAction underTest;
+// private WsActionTester wsActionTester;
+// private RuleActivator ruleActivator;
+// private OrganizationDto organization;
+//
+// @Before
+// public void setUp() {
+// dbClient = dbTester.getDbClient();
+// dbSession = dbTester.getSession();
+// esClient = esTester.client();
+// ruleIndexer = new RuleIndexer(esClient, dbClient);
+// activeRuleIndexer = new ActiveRuleIndexer(dbClient, esClient, , new ActiveRuleIteratorFactory(dbClient));
+// TestDefaultOrganizationProvider defaultOrganizationProvider = TestDefaultOrganizationProvider.from(dbTester);
+// underTest = new InheritanceAction(
+// dbClient,
+// new QProfileLookup(dbClient),
+// new QProfileWsSupport(dbClient, userSession, defaultOrganizationProvider),
+// new Languages());
+// wsActionTester = new WsActionTester(underTest);
+// ruleActivator = new RuleActivator(
+// System2.INSTANCE,
+// dbClient,
+// new RuleIndex(esClient),
+// new RuleActivatorContextFactory(dbClient),
+// new TypeValidations(new ArrayList<>()),
+// activeRuleIndexer,
+// userSession);
+// organization = dbTester.organizations().insert();
+// }
+//
+// @Test
+// public void inheritance_nominal() throws Exception {
+// RuleDefinitionDto rule1 = createRule("xoo", "rule1");
+// RuleDefinitionDto rule2 = createRule("xoo", "rule2");
+// RuleDefinitionDto rule3 = createRule("xoo", "rule3");
+//
+// /*
+// * sonar way (2) <- companyWide (2) <- buWide (2, 1 overriding) <- (forProject1 (2), forProject2 (2))
+// */
+// QProfileDto sonarway = dbTester.qualityProfiles().insert(organization, p ->
+// p.setKee("xoo-sonar-way").setLanguage("xoo").setName("Sonar way").setIsBuiltIn(true));
+// createActiveRule(rule1, sonarway);
+// createActiveRule(rule2, sonarway);
+//
+// dbSession.commit();
+// activeRuleIndexer.index();
+//
+// QProfileDto companyWide = createProfile("xoo", "My Company Profile", "xoo-my-company-profile-12345");
+// setParent(sonarway, companyWide);
+//
+// QProfileDto buWide = createProfile("xoo", "My BU Profile", "xoo-my-bu-profile-23456");
+// setParent(companyWide, buWide);
+// overrideActiveRuleSeverity(rule1, buWide, Severity.CRITICAL);
+//
+// QProfileDto forProject1 = createProfile("xoo", "For Project One", "xoo-for-project-one-34567");
+// setParent(buWide, forProject1);
+// createActiveRule(rule3, forProject1);
+// dbSession.commit();
+// activeRuleIndexer.index();
+//
+// QProfileDto forProject2 = createProfile("xoo", "For Project Two", "xoo-for-project-two-45678");
+// setParent(buWide, forProject2);
+// overrideActiveRuleSeverity(rule2, forProject2, Severity.CRITICAL);
+//
+// String response = wsActionTester.newRequest()
+// .setMethod("GET")
+// .setParam("profileKey", buWide.getKee())
+// .execute()
+// .getInput();
+//
+// JsonAssert.assertJson(response).isSimilarTo(getClass().getResource("InheritanceActionTest/inheritance-buWide.json"));
+// }
+//
+// @Test
+// public void inheritance_parent_child() throws Exception {
+// RuleDefinitionDto rule1 = dbTester.rules().insert();
+// ruleIndexer.indexRuleDefinition(rule1.getKey());
+//
+// RuleDefinitionDto rule2 = dbTester.rules().insert();
+// ruleIndexer.indexRuleDefinition(rule1.getKey());
+//
+// RuleDefinitionDto rule3 = dbTester.rules().insert();
+// ruleIndexer.indexRuleDefinition(rule1.getKey());
+//
+// QProfileDto parent = dbTester.qualityProfiles().insert(organization);
+// dbTester.qualityProfiles().activateRule(parent, rule1);
+// dbTester.qualityProfiles().activateRule(parent, rule2);
+// long parentRules = 2;
+//
+// QProfileDto child = dbTester.qualityProfiles().insert(organization, q -> q.setParentKee(parent.getKee()));
+// dbTester.qualityProfiles().activateRule(child, rule3);
+// long childRules = 1;
+//
+// activeRuleIndexer.index();
+//
+// InputStream response = wsActionTester.newRequest()
+// .setMethod("GET")
+// .setMediaType(PROTOBUF)
+// .setParam("profileKey", child.getKee())
+// .execute()
+// .getInputStream();
+//
+// InheritanceWsResponse result = InheritanceWsResponse.parseFrom(response);
+//
+// assertThat(result.getProfile().getKey()).isEqualTo(child.getKee());
+// assertThat(result.getProfile().getActiveRuleCount()).isEqualTo(childRules);
+//
+// assertThat(result.getAncestorsList()).extracting(InheritanceWsResponse.QualityProfile::getKey).containsExactly(parent.getKee());
+// assertThat(result.getAncestorsList()).extracting(InheritanceWsResponse.QualityProfile::getActiveRuleCount).containsExactly(parentRules);
+// }
+//
+// @Test
+// public void inheritance_ignores_removed_rules() throws Exception {
+// RuleDefinitionDto rule = dbTester.rules().insert(r -> r.setStatus(RuleStatus.REMOVED));
+// ruleIndexer.indexRuleDefinition(rule.getKey());
+//
+// QProfileDto profile = dbTester.qualityProfiles().insert(organization);
+// dbTester.qualityProfiles().activateRule(profile, rule);
+// long activeRules = 0;
+//
+// activeRuleIndexer.index();
+//
+// InputStream response = wsActionTester.newRequest()
+// .setMethod("GET")
+// .setMediaType(PROTOBUF)
+// .setParam("profileKey", profile.getKee())
+// .execute()
+// .getInputStream();
+//
+// InheritanceWsResponse result = InheritanceWsResponse.parseFrom(response);
+// assertThat(result.getProfile().getKey()).isEqualTo(profile.getKee());
+// assertThat(result.getProfile().getActiveRuleCount()).isEqualTo(activeRules);
+// }
+//
+// @Test
+// public void inheritance_no_family() throws Exception {
+// // Simple profile, no parent, no child
+// QProfileDto remi = createProfile("xoo", "Nobodys Boy", "xoo-nobody-s-boy-01234");
+//
+// String response = wsActionTester.newRequest()
+// .setMethod("GET")
+// .setParam("profileKey", remi.getKee())
+// .execute()
+// .getInput();
+//
+// JsonAssert.assertJson(response).isSimilarTo(getClass().getResource("InheritanceActionTest/inheritance-simple.json"));
+// }
+//
+// @Test(expected = NotFoundException.class)
+// public void fail_if_not_found() throws Exception {
+// wsActionTester.newRequest()
+// .setMethod("GET").setParam("profileKey", "polop").execute();
+// }
+//
+// private QProfileDto createProfile(String lang, String name, String key) {
+// QProfileDto profile = newQProfileDto(organization, new QProfileName(lang, name), key);
+// dbClient.qualityProfileDao().insert(dbSession, profile);
+// dbSession.commit();
+// return profile;
+// }
+//
+// private void setParent(QProfileDto profile, QProfileDto parent) {
+// ruleActivator.setParent(dbSession, parent, profile);
+// }
+//
+// private RuleDefinitionDto createRule(String lang, String id) {
+// long now = new Date().getTime();
+// RuleDefinitionDto rule = RuleTesting.newRule(RuleKey.of("blah", id))
+// .setLanguage(lang)
+// .setSeverity(Severity.BLOCKER)
+// .setStatus(RuleStatus.READY)
+// .setUpdatedAt(now)
+// .setCreatedAt(now);
+// dbClient.ruleDao().insert(dbSession, rule);
+// dbSession.commit();
+// ruleIndexer.indexRuleDefinition(rule.getKey());
+// return rule;
+// }
+//
+// private ActiveRuleDto createActiveRule(RuleDefinitionDto rule, QProfileDto profile) {
+// long now = new Date().getTime();
+// ActiveRuleDto activeRule = ActiveRuleDto.createFor(profile, rule)
+// .setSeverity(rule.getSeverityString())
+// .setUpdatedAt(now)
+// .setCreatedAt(now);
+// dbClient.activeRuleDao().insert(dbSession, activeRule);
+// return activeRule;
+// }
+//
+// private void overrideActiveRuleSeverity(RuleDefinitionDto rule, QProfileDto profile, String severity) {
+// ruleActivator.activate(dbSession, new RuleActivation(rule.getKey()).setSeverity(severity), profile.getKee());
+// dbSession.commit();
+// activeRuleIndexer.index();
+// }
}
*/
package org.sonar.server.qualityprofile.ws;
-import com.google.common.collect.ImmutableSet;
-import java.util.Collections;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.ClassRule;
-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.ws.WebService;
-import org.sonar.db.DbClient;
-import org.sonar.db.DbSession;
-import org.sonar.db.organization.OrganizationDto;
-import org.sonar.db.organization.OrganizationTesting;
-import org.sonar.db.qualityprofile.ActiveRuleDao;
-import org.sonar.db.qualityprofile.ActiveRuleDto;
-import org.sonar.db.qualityprofile.ActiveRuleKey;
-import org.sonar.db.qualityprofile.QProfileDto;
-import org.sonar.db.rule.RuleDefinitionDto;
-import org.sonar.db.rule.RuleTesting;
-import org.sonar.server.es.SearchOptions;
-import org.sonar.server.exceptions.BadRequestException;
-import org.sonar.server.qualityprofile.QProfileName;
-import org.sonar.server.qualityprofile.QProfileTesting;
-import org.sonar.server.qualityprofile.index.ActiveRuleIndexer;
-import org.sonar.server.rule.index.RuleIndex;
-import org.sonar.server.rule.index.RuleIndexer;
-import org.sonar.server.rule.index.RuleQuery;
-import org.sonar.server.tester.ServerTester;
-import org.sonar.server.tester.UserSessionRule;
-import org.sonar.server.ws.WsTester;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.fail;
-import static org.sonarqube.ws.client.qualityprofile.QualityProfileWsParameters.ACTION_ACTIVATE_RULE;
-import static org.sonarqube.ws.client.qualityprofile.QualityProfileWsParameters.ACTION_DEACTIVATE_RULE;
-import static org.sonarqube.ws.client.qualityprofile.QualityProfileWsParameters.ActivateActionParameters.PARAM_PROFILE_KEY;
-import static org.sonarqube.ws.client.qualityprofile.QualityProfileWsParameters.ActivateActionParameters.PARAM_RULE_KEY;
-import static org.sonarqube.ws.client.qualityprofile.QualityProfileWsParameters.ActivateActionParameters.PARAM_SEVERITY;
-import static org.sonarqube.ws.client.rule.RulesWsParameters.PARAM_LANGUAGES;
-import static org.sonarqube.ws.client.rule.RulesWsParameters.PARAM_QPROFILE;
-
public class QProfilesWsMediumTest {
- @ClassRule
- public static ServerTester tester = new ServerTester().withEsIndexes();
-
- @Rule
- public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester)
- .logIn().setRoot();
-
- private DbClient db;
- private DbSession session;
- private WsTester wsTester;
- private RuleIndexer ruleIndexer = tester.get(RuleIndexer.class);
- private ActiveRuleIndexer activeRuIndexer = tester.get(ActiveRuleIndexer.class);
- private OrganizationDto organization;
-
- @Before
- public void setUp() {
- tester.clearDbAndIndexes();
- db = tester.get(DbClient.class);
- wsTester = tester.get(WsTester.class);
- session = db.openSession(false);
-
- ruleIndexer = tester.get(RuleIndexer.class);
- activeRuIndexer = tester.get(ActiveRuleIndexer.class);
- organization = OrganizationTesting.newOrganizationDto().setKey("org-123");
- db.organizationDao().insert(session, organization, false);
- }
-
- @After
- public void after() {
- session.close();
- }
-
- @Test
- public void deactivate_rule() throws Exception {
- QProfileDto profile = createProfile("java");
- RuleDefinitionDto rule = createRule(profile.getLanguage(), "toto");
- createActiveRule(rule, profile);
- session.commit();
- ruleIndexer.indexRuleDefinition(rule.getKey());
- activeRuIndexer.index();
-
- // 0. Assert No Active Rule for profile
- assertThat(db.activeRuleDao().selectByProfileKey(session, profile.getKee())).hasSize(1);
-
- // 1. Deactivate Rule
- WsTester.TestRequest request = wsTester.newPostRequest(QProfilesWs.API_ENDPOINT, ACTION_DEACTIVATE_RULE);
- request.setParam(PARAM_PROFILE_KEY, profile.getKee());
- request.setParam(PARAM_RULE_KEY, rule.getKey().toString());
- request.execute();
- session.clearCache();
-
- // 2. Assert ActiveRule in DAO
- assertThat(db.activeRuleDao().selectByProfileKey(session, profile.getKee())).isEmpty();
- }
-
- @Test
- public void bulk_deactivate_rule() throws Exception {
- QProfileDto profile = createProfile("java");
- RuleDefinitionDto rule0 = createRule(profile.getLanguage(), "toto1");
- RuleDefinitionDto rule1 = createRule(profile.getLanguage(), "toto2");
- RuleDefinitionDto rule2 = createRule(profile.getLanguage(), "toto3");
- RuleDefinitionDto rule3 = createRule(profile.getLanguage(), "toto4");
- createActiveRule(rule0, profile);
- createActiveRule(rule2, profile);
- createActiveRule(rule3, profile);
- createActiveRule(rule1, profile);
- session.commit();
- activeRuIndexer.index();
-
- // 0. Assert No Active Rule for profile
- assertThat(db.activeRuleDao().selectByProfileKey(session, profile.getKee())).hasSize(4);
-
- // 1. Deactivate Rule
- WsTester.TestRequest request = wsTester.newPostRequest(QProfilesWs.API_ENDPOINT, DeactivateRulesAction.DEACTIVATE_RULES_ACTION);
- request.setParam(PARAM_PROFILE_KEY, profile.getKee());
- WsTester.Result result = request.execute();
- session.clearCache();
-
- // 2. Assert ActiveRule in DAO
- assertThat(db.activeRuleDao().selectByProfileKey(session, profile.getKee())).isEmpty();
- }
-
- @Test
- public void bulk_deactivate_rule_not_all() throws Exception {
- QProfileDto profile = createProfile("java");
- QProfileDto php = createProfile("php");
- RuleDefinitionDto rule0 = createRule(profile.getLanguage(), "toto1");
- RuleDefinitionDto rule1 = createRule(profile.getLanguage(), "toto2");
- createActiveRule(rule0, profile);
- createActiveRule(rule1, profile);
- createActiveRule(rule0, php);
- createActiveRule(rule1, php);
- session.commit();
- activeRuIndexer.index();
-
- // 0. Assert No Active Rule for profile
- assertThat(db.activeRuleDao().selectByProfileKey(session, profile.getKee())).hasSize(2);
-
- // 1. Deactivate Rule
- WsTester.TestRequest request = wsTester.newPostRequest(QProfilesWs.API_ENDPOINT, DeactivateRulesAction.DEACTIVATE_RULES_ACTION);
- request.setParam(PARAM_PROFILE_KEY, profile.getKee());
- WsTester.Result result = request.execute();
- session.clearCache();
-
- // 2. Assert ActiveRule in DAO
- assertThat(db.activeRuleDao().selectByProfileKey(session, profile.getKee())).hasSize(0);
- assertThat(db.activeRuleDao().selectByProfileKey(session, php.getKee())).hasSize(2);
- }
-
- @Test
- public void bulk_deactivate_rule_by_profile() throws Exception {
- QProfileDto profile = createProfile("java");
- RuleDefinitionDto rule0 = createRule(profile.getLanguage(), "hello");
- RuleDefinitionDto rule1 = createRule(profile.getLanguage(), "world");
- createActiveRule(rule0, profile);
- createActiveRule(rule1, profile);
- session.commit();
- activeRuIndexer.index();
-
- // 0. Assert No Active Rule for profile
- assertThat(db.activeRuleDao().selectByProfileKey(session, profile.getKee())).hasSize(2);
-
- // 1. Deactivate Rule
- WsTester.TestRequest request = wsTester.newPostRequest(QProfilesWs.API_ENDPOINT, DeactivateRulesAction.DEACTIVATE_RULES_ACTION);
- request.setParam(PARAM_PROFILE_KEY, profile.getKee());
- request.setParam(WebService.Param.TEXT_QUERY, "hello");
- WsTester.Result result = request.execute();
- session.clearCache();
-
- // 2. Assert ActiveRule in DAO
- assertThat(db.activeRuleDao().selectByProfileKey(session, profile.getKee())).hasSize(1);
- }
-
- @Test
- public void activate_rule() throws Exception {
- QProfileDto profile = createProfile("java");
- RuleDefinitionDto rule = createRule(profile.getLanguage(), "toto");
- session.commit();
- ruleIndexer.indexRuleDefinition(rule.getKey());
-
- // 0. Assert No Active Rule for profile
- assertThat(db.activeRuleDao().selectByProfileKey(session, profile.getKee())).isEmpty();
-
- // 1. Activate Rule
- WsTester.TestRequest request = wsTester.newPostRequest(QProfilesWs.API_ENDPOINT, ACTION_ACTIVATE_RULE);
- request.setParam(PARAM_PROFILE_KEY, profile.getKee());
- request.setParam(PARAM_RULE_KEY, rule.getKey().toString());
- WsTester.Result result = request.execute();
- session.clearCache();
-
- // 2. Assert ActiveRule in DAO
- assertThat(db.activeRuleDao().selectByProfileKey(session, profile.getKee())).hasSize(1);
- }
-
- @Test
- public void activate_rule_diff_languages() throws Exception {
- QProfileDto profile = createProfile("java");
- RuleDefinitionDto rule = createRule("php", "toto");
- session.commit();
- ruleIndexer.indexRuleDefinition(rule.getKey());
-
- // 0. Assert No Active Rule for profile
- assertThat(db.activeRuleDao().selectByProfileKey(session, profile.getKee())).isEmpty();
-
- try {
- // 1. Activate Rule
- WsTester.TestRequest request = wsTester.newPostRequest(QProfilesWs.API_ENDPOINT, ACTION_ACTIVATE_RULE);
- request.setParam(PARAM_PROFILE_KEY, profile.getKee());
- request.setParam(PARAM_RULE_KEY, rule.getKey().toString());
- request.execute();
- session.clearCache();
- fail();
- } catch (BadRequestException e) {
- assertThat(e.getMessage()).isEqualTo("Rule blah:toto and profile pjava have different languages");
- }
- }
-
- @Test
- public void activate_rule_override_severity() throws Exception {
- QProfileDto profile = createProfile("java");
- RuleDefinitionDto rule = createRule(profile.getLanguage(), "toto");
- session.commit();
- ruleIndexer.indexRuleDefinition(rule.getKey());
-
- // 0. Assert No Active Rule for profile
- assertThat(db.activeRuleDao().selectByProfileKey(session, profile.getKee())).isEmpty();
-
- // 1. Activate Rule
- WsTester.TestRequest request = wsTester.newPostRequest(QProfilesWs.API_ENDPOINT, ACTION_ACTIVATE_RULE);
- request.setParam(PARAM_PROFILE_KEY, profile.getKee());
- request.setParam(PARAM_RULE_KEY, rule.getKey().toString());
- request.setParam(PARAM_SEVERITY, "MINOR");
- WsTester.Result result = request.execute();
- session.clearCache();
-
- // 2. Assert ActiveRule in DAO
- ActiveRuleKey activeRuleKey = ActiveRuleKey.of(profile.getKee(), rule.getKey());
-
- assertThat(db.activeRuleDao().selectOrFailByKey(session, activeRuleKey).getSeverityString())
- .isEqualTo("MINOR");
- }
-
- @Test
- public void bulk_activate_rule() throws Exception {
- QProfileDto profile = createProfile("java");
- createRule(profile.getLanguage(), "toto");
- createRule(profile.getLanguage(), "tata");
- createRule(profile.getLanguage(), "hello");
- createRule(profile.getLanguage(), "world");
- session.commit();
-
- // 0. Assert No Active Rule for profile
- assertThat(db.activeRuleDao().selectByProfileKey(session, profile.getKee())).isEmpty();
-
- // 1. Activate Rule
- WsTester.TestRequest request = wsTester.newPostRequest(QProfilesWs.API_ENDPOINT, ActivateRulesAction.ACTIVATE_RULES_ACTION);
- request.setParam(PARAM_PROFILE_KEY, profile.getKee());
- request.setParam(PARAM_LANGUAGES, "java");
- request.execute().assertJson(getClass(), "bulk_activate_rule.json");
- session.clearCache();
-
- // 2. Assert ActiveRule in DAO
- assertThat(db.activeRuleDao().selectByProfileKey(session, profile.getKee())).hasSize(4);
- }
-
- @Test
- public void bulk_activate_rule_not_all() throws Exception {
- QProfileDto java = createProfile("java");
- QProfileDto php = createProfile("php");
- createRule(java.getLanguage(), "toto");
- createRule(java.getLanguage(), "tata");
- createRule(php.getLanguage(), "hello");
- createRule(php.getLanguage(), "world");
- session.commit();
-
- // 0. Assert No Active Rule for profile
- assertThat(db.activeRuleDao().selectByProfileKey(session, php.getKee())).isEmpty();
-
- // 1. Activate Rule
- WsTester.TestRequest request = wsTester.newPostRequest(QProfilesWs.API_ENDPOINT, ActivateRulesAction.ACTIVATE_RULES_ACTION);
- request.setParam(PARAM_PROFILE_KEY, php.getKee());
- request.setParam(PARAM_LANGUAGES, "php");
- request.execute().assertJson(getClass(), "bulk_activate_rule_not_all.json");
- session.clearCache();
-
- // 2. Assert ActiveRule in DAO
- assertThat(db.activeRuleDao().selectByProfileKey(session, php.getKee())).hasSize(2);
- }
-
- @Test
- public void bulk_activate_rule_by_query() throws Exception {
- QProfileDto profile = createProfile("java");
- createRule(profile.getLanguage(), "toto");
- createRule(profile.getLanguage(), "tata");
- createRule(profile.getLanguage(), "hello");
- createRule(profile.getLanguage(), "world");
- session.commit();
-
- // 0. Assert No Active Rule for profile
- assertThat(db.activeRuleDao().selectByProfileKey(session, profile.getKee())).isEmpty();
-
- // 1. Activate Rule with query returning 0 hits
- WsTester.TestRequest request = wsTester.newPostRequest(QProfilesWs.API_ENDPOINT, ActivateRulesAction.ACTIVATE_RULES_ACTION);
- request.setParam(PARAM_PROFILE_KEY, profile.getKee());
- request.setParam(WebService.Param.TEXT_QUERY, "php");
- request.execute();
- session.clearCache();
-
- // 2. Assert ActiveRule in DAO
- assertThat(db.activeRuleDao().selectByProfileKey(session, profile.getKee())).hasSize(0);
-
- // 1. Activate Rule with query returning 1 hits
- request = wsTester.newPostRequest(QProfilesWs.API_ENDPOINT, ActivateRulesAction.ACTIVATE_RULES_ACTION);
- request.setParam(PARAM_PROFILE_KEY, profile.getKee());
- request.setParam(WebService.Param.TEXT_QUERY, "world");
- request.execute();
- session.commit();
-
- // 2. Assert ActiveRule in DAO
- assertThat(db.activeRuleDao().selectByProfileKey(session, profile.getKee())).hasSize(1);
- }
-
- @Test
- public void bulk_activate_rule_by_query_with_severity() throws Exception {
- QProfileDto profile = createProfile("java");
- RuleDefinitionDto rule0 = createRule(profile.getLanguage(), "toto");
- RuleDefinitionDto rule1 = createRule(profile.getLanguage(), "tata");
- session.commit();
-
- // 0. Assert No Active Rule for profile
- assertThat(db.activeRuleDao().selectByProfileKey(session, profile.getKee())).isEmpty();
-
- // 2. Assert ActiveRule with BLOCKER severity
- assertThat(tester.get(RuleIndex.class).search(
- new RuleQuery().setSeverities(ImmutableSet.of("BLOCKER")),
- new SearchOptions()).getIds()).hasSize(2);
-
- // 1. Activate Rule with query returning 2 hits
- WsTester.TestRequest request = wsTester.newPostRequest(QProfilesWs.API_ENDPOINT, ActivateRulesAction.ACTIVATE_RULES_ACTION);
- request.setParam(ActivateRulesAction.PROFILE_KEY, profile.getKee());
- request.setParam(ActivateRulesAction.SEVERITY, "MINOR");
- request.execute();
- session.commit();
-
- // 2. Assert ActiveRule with MINOR severity
- assertThat(tester.get(ActiveRuleDao.class).selectByRuleId(session, organization, rule0.getId()).get(0).getSeverityString()).isEqualTo("MINOR");
- assertThat(tester.get(RuleIndex.class).searchAll(new RuleQuery()
- .setQProfileKey(profile.getKee())
- .setKey(rule0.getKey().toString())
- .setActiveSeverities(Collections.singleton("MINOR"))
- .setActivation(true))).hasSize(1);
- }
-
- @Test
- public void does_not_return_warnings_when_bulk_activate_on_profile_and_rules_exist_on_another_language_than_profile() throws Exception {
- QProfileDto javaProfile = createProfile("java");
- createRule(javaProfile.getLanguage(), "toto");
- createRule(javaProfile.getLanguage(), "tata");
- QProfileDto phpProfile = createProfile("php");
- createRule(phpProfile.getLanguage(), "hello");
- createRule(phpProfile.getLanguage(), "world");
- session.commit();
-
- // 1. Activate Rule
- WsTester.TestRequest request = wsTester.newPostRequest(QProfilesWs.API_ENDPOINT, ActivateRulesAction.ACTIVATE_RULES_ACTION);
- request.setParam(PARAM_PROFILE_KEY, javaProfile.getKee());
- request.setParam(PARAM_QPROFILE, javaProfile.getKee());
- request.setParam("activation", "false");
- request.execute().assertJson(getClass(), "does_not_return_warnings_when_bulk_activate_on_profile_and_rules_exist_on_another_language_than_profile.json");
- session.clearCache();
-
- // 2. Assert ActiveRule in DAO
- assertThat(db.activeRuleDao().selectByProfileKey(session, javaProfile.getKee())).hasSize(2);
- }
-
- @Test
- public void reset() throws Exception {
- QProfileDto profile = QProfileTesting.newXooP1(organization);
- QProfileDto subProfile = QProfileTesting.newXooP2(organization).setParentKee(QProfileTesting.XOO_P1_KEY);
- db.qualityProfileDao().insert(session, profile, subProfile);
-
- RuleDefinitionDto rule = createRule(profile.getLanguage(), "rule");
- ActiveRuleDto active1 = ActiveRuleDto.createFor(profile, rule)
- .setSeverity(rule.getSeverityString());
- ActiveRuleDto active2 = ActiveRuleDto.createFor(subProfile, rule)
- .setSeverity("MINOR");
- db.activeRuleDao().insert(session, active1);
- db.activeRuleDao().insert(session, active2);
-
- session.commit();
- activeRuIndexer.index();
-
- // 0. assert rule child rule is minor
- assertThat(db.activeRuleDao().selectOrFailByKey(session, active2.getKey()).getSeverityString()).isEqualTo("MINOR");
-
- // 1. reset child rule
- WsTester.TestRequest request = wsTester.newPostRequest(QProfilesWs.API_ENDPOINT, ACTION_ACTIVATE_RULE);
- request.setParam("profile_key", subProfile.getKee());
- request.setParam("rule_key", rule.getKey().toString());
- request.setParam("reset", "true");
- request.execute();
- session.clearCache();
-
- // 2. assert rule child rule is NOT minor
- assertThat(db.activeRuleDao().selectOrFailByKey(session, active2.getKey()).getSeverityString()).isNotEqualTo("MINOR");
- }
-
- private QProfileDto createProfile(String lang) {
- QProfileDto profile = QProfileTesting.newQProfileDto(organization, new QProfileName(lang, "P" + lang), "p" + lang);
- db.qualityProfileDao().insert(session, profile);
- return profile;
- }
-
- private RuleDefinitionDto createRule(String lang, String id) {
- RuleDefinitionDto rule = RuleTesting.newRule(RuleKey.of("blah", id))
- .setLanguage(lang)
- .setSeverity(Severity.BLOCKER)
- .setStatus(RuleStatus.READY);
- db.ruleDao().insert(session, rule);
- session.commit();
- ruleIndexer.indexRuleDefinition(rule.getKey());
- return rule;
- }
-
- private ActiveRuleDto createActiveRule(RuleDefinitionDto rule, QProfileDto profile) {
- ActiveRuleDto activeRule = ActiveRuleDto.createFor(profile, rule)
- .setSeverity(rule.getSeverityString());
- db.activeRuleDao().insert(session, activeRule);
- return activeRule;
- }
+// @ClassRule
+// public static ServerTester tester = new ServerTester().withEsIndexes();
+//
+// @Rule
+// public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester)
+// .logIn().setRoot();
+//
+// private DbClient db;
+// private DbSession session;
+// private WsTester wsTester;
+// private RuleIndexer ruleIndexer = tester.get(RuleIndexer.class);
+// private ActiveRuleIndexer activeRuIndexer = tester.get(ActiveRuleIndexer.class);
+// private OrganizationDto organization;
+//
+// @Before
+// public void setUp() {
+// tester.clearDbAndIndexes();
+// db = tester.get(DbClient.class);
+// wsTester = tester.get(WsTester.class);
+// session = db.openSession(false);
+//
+// ruleIndexer = tester.get(RuleIndexer.class);
+// activeRuIndexer = tester.get(ActiveRuleIndexer.class);
+// organization = OrganizationTesting.newOrganizationDto().setKey("org-123");
+// db.organizationDao().insert(session, organization, false);
+// }
+//
+// @After
+// public void after() {
+// session.close();
+// }
+//
+// @Test
+// public void deactivate_rule() throws Exception {
+// QProfileDto profile = createProfile("java");
+// RuleDefinitionDto rule = createRule(profile.getLanguage(), "toto");
+// createActiveRule(rule, profile);
+// session.commit();
+// ruleIndexer.indexRuleDefinition(rule.getKey());
+// activeRuIndexer.index();
+//
+// // 0. Assert No Active Rule for profile
+// assertThat(db.activeRuleDao().selectByProfileUuid(session, profile.getKee())).hasSize(1);
+//
+// // 1. Deactivate Rule
+// WsTester.TestRequest request = wsTester.newPostRequest(QProfilesWs.API_ENDPOINT, ACTION_DEACTIVATE_RULE);
+// request.setParam(PARAM_PROFILE_KEY, profile.getKee());
+// request.setParam(PARAM_RULE_KEY, rule.getKey().toString());
+// request.execute();
+// session.clearCache();
+//
+// // 2. Assert ActiveRule in DAO
+// assertThat(db.activeRuleDao().selectByProfileUuid(session, profile.getKee())).isEmpty();
+// }
+//
+// @Test
+// public void bulk_deactivate_rule() throws Exception {
+// QProfileDto profile = createProfile("java");
+// RuleDefinitionDto rule0 = createRule(profile.getLanguage(), "toto1");
+// RuleDefinitionDto rule1 = createRule(profile.getLanguage(), "toto2");
+// RuleDefinitionDto rule2 = createRule(profile.getLanguage(), "toto3");
+// RuleDefinitionDto rule3 = createRule(profile.getLanguage(), "toto4");
+// createActiveRule(rule0, profile);
+// createActiveRule(rule2, profile);
+// createActiveRule(rule3, profile);
+// createActiveRule(rule1, profile);
+// session.commit();
+// activeRuIndexer.index();
+//
+// // 0. Assert No Active Rule for profile
+// assertThat(db.activeRuleDao().selectByProfileUuid(session, profile.getKee())).hasSize(4);
+//
+// // 1. Deactivate Rule
+// WsTester.TestRequest request = wsTester.newPostRequest(QProfilesWs.API_ENDPOINT, DeactivateRulesAction.DEACTIVATE_RULES_ACTION);
+// request.setParam(PARAM_PROFILE_KEY, profile.getKee());
+// WsTester.Result result = request.execute();
+// session.clearCache();
+//
+// // 2. Assert ActiveRule in DAO
+// assertThat(db.activeRuleDao().selectByProfileUuid(session, profile.getKee())).isEmpty();
+// }
+//
+// @Test
+// public void bulk_deactivate_rule_not_all() throws Exception {
+// QProfileDto profile = createProfile("java");
+// QProfileDto php = createProfile("php");
+// RuleDefinitionDto rule0 = createRule(profile.getLanguage(), "toto1");
+// RuleDefinitionDto rule1 = createRule(profile.getLanguage(), "toto2");
+// createActiveRule(rule0, profile);
+// createActiveRule(rule1, profile);
+// createActiveRule(rule0, php);
+// createActiveRule(rule1, php);
+// session.commit();
+// activeRuIndexer.index();
+//
+// // 0. Assert No Active Rule for profile
+// assertThat(db.activeRuleDao().selectByProfileUuid(session, profile.getKee())).hasSize(2);
+//
+// // 1. Deactivate Rule
+// WsTester.TestRequest request = wsTester.newPostRequest(QProfilesWs.API_ENDPOINT, DeactivateRulesAction.DEACTIVATE_RULES_ACTION);
+// request.setParam(PARAM_PROFILE_KEY, profile.getKee());
+// WsTester.Result result = request.execute();
+// session.clearCache();
+//
+// // 2. Assert ActiveRule in DAO
+// assertThat(db.activeRuleDao().selectByProfileUuid(session, profile.getKee())).hasSize(0);
+// assertThat(db.activeRuleDao().selectByProfileUuid(session, php.getKee())).hasSize(2);
+// }
+//
+// @Test
+// public void bulk_deactivate_rule_by_profile() throws Exception {
+// QProfileDto profile = createProfile("java");
+// RuleDefinitionDto rule0 = createRule(profile.getLanguage(), "hello");
+// RuleDefinitionDto rule1 = createRule(profile.getLanguage(), "world");
+// createActiveRule(rule0, profile);
+// createActiveRule(rule1, profile);
+// session.commit();
+// activeRuIndexer.index();
+//
+// // 0. Assert No Active Rule for profile
+// assertThat(db.activeRuleDao().selectByProfileUuid(session, profile.getKee())).hasSize(2);
+//
+// // 1. Deactivate Rule
+// WsTester.TestRequest request = wsTester.newPostRequest(QProfilesWs.API_ENDPOINT, DeactivateRulesAction.DEACTIVATE_RULES_ACTION);
+// request.setParam(PARAM_PROFILE_KEY, profile.getKee());
+// request.setParam(WebService.Param.TEXT_QUERY, "hello");
+// WsTester.Result result = request.execute();
+// session.clearCache();
+//
+// // 2. Assert ActiveRule in DAO
+// assertThat(db.activeRuleDao().selectByProfileUuid(session, profile.getKee())).hasSize(1);
+// }
+//
+// @Test
+// public void activate_rule() throws Exception {
+// QProfileDto profile = createProfile("java");
+// RuleDefinitionDto rule = createRule(profile.getLanguage(), "toto");
+// session.commit();
+// ruleIndexer.indexRuleDefinition(rule.getKey());
+//
+// // 0. Assert No Active Rule for profile
+// assertThat(db.activeRuleDao().selectByProfileUuid(session, profile.getKee())).isEmpty();
+//
+// // 1. Activate Rule
+// WsTester.TestRequest request = wsTester.newPostRequest(QProfilesWs.API_ENDPOINT, ACTION_ACTIVATE_RULE);
+// request.setParam(PARAM_PROFILE_KEY, profile.getKee());
+// request.setParam(PARAM_RULE_KEY, rule.getKey().toString());
+// WsTester.Result result = request.execute();
+// session.clearCache();
+//
+// // 2. Assert ActiveRule in DAO
+// assertThat(db.activeRuleDao().selectByProfileUuid(session, profile.getKee())).hasSize(1);
+// }
+//
+// @Test
+// public void activate_rule_diff_languages() throws Exception {
+// QProfileDto profile = createProfile("java");
+// RuleDefinitionDto rule = createRule("php", "toto");
+// session.commit();
+// ruleIndexer.indexRuleDefinition(rule.getKey());
+//
+// // 0. Assert No Active Rule for profile
+// assertThat(db.activeRuleDao().selectByProfileUuid(session, profile.getKee())).isEmpty();
+//
+// try {
+// // 1. Activate Rule
+// WsTester.TestRequest request = wsTester.newPostRequest(QProfilesWs.API_ENDPOINT, ACTION_ACTIVATE_RULE);
+// request.setParam(PARAM_PROFILE_KEY, profile.getKee());
+// request.setParam(PARAM_RULE_KEY, rule.getKey().toString());
+// request.execute();
+// session.clearCache();
+// fail();
+// } catch (BadRequestException e) {
+// assertThat(e.getMessage()).isEqualTo("Rule blah:toto and profile pjava have different languages");
+// }
+// }
+//
+// @Test
+// public void activate_rule_override_severity() throws Exception {
+// QProfileDto profile = createProfile("java");
+// RuleDefinitionDto rule = createRule(profile.getLanguage(), "toto");
+// session.commit();
+// ruleIndexer.indexRuleDefinition(rule.getKey());
+//
+// // 0. Assert No Active Rule for profile
+// assertThat(db.activeRuleDao().selectByProfileUuid(session, profile.getKee())).isEmpty();
+//
+// // 1. Activate Rule
+// WsTester.TestRequest request = wsTester.newPostRequest(QProfilesWs.API_ENDPOINT, ACTION_ACTIVATE_RULE);
+// request.setParam(PARAM_PROFILE_KEY, profile.getKee());
+// request.setParam(PARAM_RULE_KEY, rule.getKey().toString());
+// request.setParam(PARAM_SEVERITY, "MINOR");
+// WsTester.Result result = request.execute();
+// session.clearCache();
+//
+// // 2. Assert ActiveRule in DAO
+// ActiveRuleKey activeRuleKey = ActiveRuleKey.of(profile.getKee(), rule.getKey());
+//
+// assertThat(db.activeRuleDao().selectOrFailByKey(session, activeRuleKey).getSeverityString())
+// .isEqualTo("MINOR");
+// }
+//
+// @Test
+// public void bulk_activate_rule() throws Exception {
+// QProfileDto profile = createProfile("java");
+// createRule(profile.getLanguage(), "toto");
+// createRule(profile.getLanguage(), "tata");
+// createRule(profile.getLanguage(), "hello");
+// createRule(profile.getLanguage(), "world");
+// session.commit();
+//
+// // 0. Assert No Active Rule for profile
+// assertThat(db.activeRuleDao().selectByProfileUuid(session, profile.getKee())).isEmpty();
+//
+// // 1. Activate Rule
+// WsTester.TestRequest request = wsTester.newPostRequest(QProfilesWs.API_ENDPOINT, ActivateRulesAction.ACTIVATE_RULES_ACTION);
+// request.setParam(PARAM_PROFILE_KEY, profile.getKee());
+// request.setParam(PARAM_LANGUAGES, "java");
+// request.execute().assertJson(getClass(), "bulk_activate_rule.json");
+// session.clearCache();
+//
+// // 2. Assert ActiveRule in DAO
+// assertThat(db.activeRuleDao().selectByProfileUuid(session, profile.getKee())).hasSize(4);
+// }
+//
+// @Test
+// public void bulk_activate_rule_not_all() throws Exception {
+// QProfileDto java = createProfile("java");
+// QProfileDto php = createProfile("php");
+// createRule(java.getLanguage(), "toto");
+// createRule(java.getLanguage(), "tata");
+// createRule(php.getLanguage(), "hello");
+// createRule(php.getLanguage(), "world");
+// session.commit();
+//
+// // 0. Assert No Active Rule for profile
+// assertThat(db.activeRuleDao().selectByProfileUuid(session, php.getKee())).isEmpty();
+//
+// // 1. Activate Rule
+// WsTester.TestRequest request = wsTester.newPostRequest(QProfilesWs.API_ENDPOINT, ActivateRulesAction.ACTIVATE_RULES_ACTION);
+// request.setParam(PARAM_PROFILE_KEY, php.getKee());
+// request.setParam(PARAM_LANGUAGES, "php");
+// request.execute().assertJson(getClass(), "bulk_activate_rule_not_all.json");
+// session.clearCache();
+//
+// // 2. Assert ActiveRule in DAO
+// assertThat(db.activeRuleDao().selectByProfileUuid(session, php.getKee())).hasSize(2);
+// }
+//
+// @Test
+// public void bulk_activate_rule_by_query() throws Exception {
+// QProfileDto profile = createProfile("java");
+// createRule(profile.getLanguage(), "toto");
+// createRule(profile.getLanguage(), "tata");
+// createRule(profile.getLanguage(), "hello");
+// createRule(profile.getLanguage(), "world");
+// session.commit();
+//
+// // 0. Assert No Active Rule for profile
+// assertThat(db.activeRuleDao().selectByProfileUuid(session, profile.getKee())).isEmpty();
+//
+// // 1. Activate Rule with query returning 0 hits
+// WsTester.TestRequest request = wsTester.newPostRequest(QProfilesWs.API_ENDPOINT, ActivateRulesAction.ACTIVATE_RULES_ACTION);
+// request.setParam(PARAM_PROFILE_KEY, profile.getKee());
+// request.setParam(WebService.Param.TEXT_QUERY, "php");
+// request.execute();
+// session.clearCache();
+//
+// // 2. Assert ActiveRule in DAO
+// assertThat(db.activeRuleDao().selectByProfileUuid(session, profile.getKee())).hasSize(0);
+//
+// // 1. Activate Rule with query returning 1 hits
+// request = wsTester.newPostRequest(QProfilesWs.API_ENDPOINT, ActivateRulesAction.ACTIVATE_RULES_ACTION);
+// request.setParam(PARAM_PROFILE_KEY, profile.getKee());
+// request.setParam(WebService.Param.TEXT_QUERY, "world");
+// request.execute();
+// session.commit();
+//
+// // 2. Assert ActiveRule in DAO
+// assertThat(db.activeRuleDao().selectByProfileUuid(session, profile.getKee())).hasSize(1);
+// }
+//
+// @Test
+// public void bulk_activate_rule_by_query_with_severity() throws Exception {
+// QProfileDto profile = createProfile("java");
+// RuleDefinitionDto rule0 = createRule(profile.getLanguage(), "toto");
+// RuleDefinitionDto rule1 = createRule(profile.getLanguage(), "tata");
+// session.commit();
+//
+// // 0. Assert No Active Rule for profile
+// assertThat(db.activeRuleDao().selectByProfileUuid(session, profile.getKee())).isEmpty();
+//
+// // 2. Assert ActiveRule with BLOCKER severity
+// assertThat(tester.get(RuleIndex.class).search(
+// new RuleQuery().setSeverities(ImmutableSet.of("BLOCKER")),
+// new SearchOptions()).getIds()).hasSize(2);
+//
+// // 1. Activate Rule with query returning 2 hits
+// WsTester.TestRequest request = wsTester.newPostRequest(QProfilesWs.API_ENDPOINT, ActivateRulesAction.ACTIVATE_RULES_ACTION);
+// request.setParam(ActivateRulesAction.PROFILE_KEY, profile.getKee());
+// request.setParam(ActivateRulesAction.SEVERITY, "MINOR");
+// request.execute();
+// session.commit();
+//
+// // 2. Assert ActiveRule with MINOR severity
+// assertThat(tester.get(ActiveRuleDao.class).selectByRuleId(session, organization, rule0.getId()).get(0).getSeverityString()).isEqualTo("MINOR");
+// assertThat(tester.get(RuleIndex.class).searchAll(new RuleQuery()
+// .setQProfileKey(profile.getKee())
+// .setKey(rule0.getKey().toString())
+// .setActiveSeverities(Collections.singleton("MINOR"))
+// .setActivation(true))).hasSize(1);
+// }
+//
+// @Test
+// public void does_not_return_warnings_when_bulk_activate_on_profile_and_rules_exist_on_another_language_than_profile() throws Exception {
+// QProfileDto javaProfile = createProfile("java");
+// createRule(javaProfile.getLanguage(), "toto");
+// createRule(javaProfile.getLanguage(), "tata");
+// QProfileDto phpProfile = createProfile("php");
+// createRule(phpProfile.getLanguage(), "hello");
+// createRule(phpProfile.getLanguage(), "world");
+// session.commit();
+//
+// // 1. Activate Rule
+// WsTester.TestRequest request = wsTester.newPostRequest(QProfilesWs.API_ENDPOINT, ActivateRulesAction.ACTIVATE_RULES_ACTION);
+// request.setParam(PARAM_PROFILE_KEY, javaProfile.getKee());
+// request.setParam(PARAM_QPROFILE, javaProfile.getKee());
+// request.setParam("activation", "false");
+// request.execute().assertJson(getClass(), "does_not_return_warnings_when_bulk_activate_on_profile_and_rules_exist_on_another_language_than_profile.json");
+// session.clearCache();
+//
+// // 2. Assert ActiveRule in DAO
+// assertThat(db.activeRuleDao().selectByProfileUuid(session, javaProfile.getKee())).hasSize(2);
+// }
+//
+// @Test
+// public void reset() throws Exception {
+// QProfileDto profile = QProfileTesting.newXooP1(organization);
+// QProfileDto subProfile = QProfileTesting.newXooP2(organization).setParentKee(QProfileTesting.XOO_P1_KEY);
+// db.qualityProfileDao().insert(session, profile, subProfile);
+//
+// RuleDefinitionDto rule = createRule(profile.getLanguage(), "rule");
+// ActiveRuleDto active1 = ActiveRuleDto.createFor(profile, rule)
+// .setSeverity(rule.getSeverityString());
+// ActiveRuleDto active2 = ActiveRuleDto.createFor(subProfile, rule)
+// .setSeverity("MINOR");
+// db.activeRuleDao().insert(session, active1);
+// db.activeRuleDao().insert(session, active2);
+//
+// session.commit();
+// activeRuIndexer.index();
+//
+// // 0. assert rule child rule is minor
+// assertThat(db.activeRuleDao().selectOrFailByKey(session, active2.getKey()).getSeverityString()).isEqualTo("MINOR");
+//
+// // 1. reset child rule
+// WsTester.TestRequest request = wsTester.newPostRequest(QProfilesWs.API_ENDPOINT, ACTION_ACTIVATE_RULE);
+// request.setParam("profile_key", subProfile.getKee());
+// request.setParam("rule_key", rule.getKey().toString());
+// request.setParam("reset", "true");
+// request.execute();
+// session.clearCache();
+//
+// // 2. assert rule child rule is NOT minor
+// assertThat(db.activeRuleDao().selectOrFailByKey(session, active2.getKey()).getSeverityString()).isNotEqualTo("MINOR");
+// }
+//
+// private QProfileDto createProfile(String lang) {
+// QProfileDto profile = QProfileTesting.newQProfileDto(organization, new QProfileName(lang, "P" + lang), "p" + lang);
+// db.qualityProfileDao().insert(session, profile);
+// return profile;
+// }
+//
+// private RuleDefinitionDto createRule(String lang, String id) {
+// RuleDefinitionDto rule = RuleTesting.newRule(RuleKey.of("blah", id))
+// .setLanguage(lang)
+// .setSeverity(Severity.BLOCKER)
+// .setStatus(RuleStatus.READY);
+// db.ruleDao().insert(session, rule);
+// session.commit();
+// ruleIndexer.indexRuleDefinition(rule.getKey());
+// return rule;
+// }
+//
+// private ActiveRuleDto createActiveRule(RuleDefinitionDto rule, QProfileDto profile) {
+// ActiveRuleDto activeRule = ActiveRuleDto.createFor(profile, rule)
+// .setSeverity(rule.getSeverityString());
+// db.activeRuleDao().insert(session, activeRule);
+// return activeRule;
+// }
}
}
private void createProfiles() {
- String orgUuid = organization.getUuid();
- dbClient.qualityProfileDao().insert(db.getSession(),
- QProfileDto.createFor("sonar-way-xoo1-12345")
- .setOrganizationUuid(orgUuid)
- .setLanguage(xoo1Key)
- .setName("Sonar way"),
-
- QProfileDto.createFor("sonar-way-xoo2-23456")
- .setOrganizationUuid(orgUuid)
- .setLanguage(xoo2Key)
- .setName("Sonar way"),
-
- QProfileDto.createFor("my-sonar-way-xoo2-34567")
- .setOrganizationUuid(orgUuid)
- .setLanguage(xoo2Key)
- .setName("My Sonar way")
- .setParentKee("sonar-way-xoo2-23456"));
- db.commit();
+ db.qualityProfiles().insert(organization, p ->
+ p.setKee("sonar-way-xoo1-12345").setLanguage(xoo1Key).setName("Sonar way"));
+
+ QProfileDto parentXoo2 = db.qualityProfiles().insert(organization, p ->
+ p.setKee("sonar-way-xoo2-23456").setLanguage(xoo2Key).setName("Sonar way"));
+
+ db.qualityProfiles().insert(organization, p ->
+ p.setKee("my-sonar-way-xoo2-34567").setLanguage(xoo2Key).setName("My Sonar way").setParentKee(parentXoo2.getKee()));
}
private void logInAsQProfileAdministrator() {
} catch (IOException e) {
throw new IllegalStateException(e);
}
- QProfileDto profile = QProfileDto.createFor("P1")
+ QProfileDto profile = new QProfileDto()
+ .setKee("P1")
+ .setRulesProfileUuid("rp-P1")
.setLanguage("xoo")
.setName(overriddenProfileName != null ? overriddenProfileName : "the-name-in-backup");
restoredSummary = new QProfileRestoreSummary(profile, new BulkChangeResult());
public void ws_returns_the_profiles_of_default_organization() throws Exception {
OrganizationDto organization = getDefaultOrganization();
- QProfileDto defaultProfile = QProfileDto.createFor("sonar-way-xoo1-12345")
- .setOrganizationUuid(organization.getUuid())
- .setLanguage(xoo1.getKey())
- .setName("Sonar way")
- .setIsBuiltIn(false);
- QProfileDto parentProfile = QProfileDto
- .createFor("sonar-way-xoo2-23456")
- .setOrganizationUuid(organization.getUuid())
- .setLanguage(xoo2.getKey())
- .setName("Sonar way")
- .setIsBuiltIn(true);
- QProfileDto childProfile = QProfileDto
- .createFor("my-sonar-way-xoo2-34567")
- .setOrganizationUuid(organization.getUuid())
- .setLanguage(xoo2.getKey())
- .setName("My Sonar way")
- .setParentKee(parentProfile.getKee());
- QProfileDto profileOnUnknownLang = QProfileDto.createFor("sonar-way-other-666")
- .setOrganizationUuid(organization.getUuid())
- .setLanguage("other")
- .setName("Sonar way");
- qualityProfileDao.insert(dbSession, defaultProfile, parentProfile, childProfile, profileOnUnknownLang);
+ QProfileDto defaultProfile = db.qualityProfiles().insert(organization, p ->
+ p.setLanguage(xoo1.getKey()).setName("Sonar way").setKee("sonar-way-xoo1-12345").setIsBuiltIn(false));
+ QProfileDto parentProfile = db.qualityProfiles().insert(organization, p ->
+ p.setLanguage(xoo2.getKey()).setName("Sonar way").setKee("sonar-way-xoo2-23456").setIsBuiltIn(true));
+ QProfileDto childProfile = db.qualityProfiles().insert(organization, p ->
+ p.setLanguage(xoo2.getKey()).setName("My Sonar way").setKee("my-sonar-way-xoo2-34567").setIsBuiltIn(false).setParentKee(parentProfile.getKee()));
+ QProfileDto profileOnUnknownLang = db.qualityProfiles().insert(organization, p ->
+ p.setLanguage("other").setName("Sonar way").setKee("sonar-way-other-666"));
db.qualityProfiles().setAsDefault(defaultProfile, profileOnUnknownLang);
ComponentDto project1 = db.components().insertPrivateProject(organization);
@Test
public void search_for_language() throws Exception {
qualityProfileDb.insert(
- QProfileDto.createFor("sonar-way-xoo1-12345")
+ new QProfileDto()
+ .setKee("sonar-way-xoo1-12345")
+ .setRulesProfileUuid("rp-sonar-way-xoo1-12345")
.setOrganizationUuid(defaultOrganizationProvider.get().getUuid())
.setLanguage(xoo1.getKey())
.setName("Sonar way"));
@Test
public void search_for_default_qp_with_profile_name() {
String orgUuid = defaultOrganizationProvider.get().getUuid();
- QProfileDto qualityProfileOnXoo1 = QProfileDto.createFor("sonar-way-xoo1-12345")
+ QProfileDto qualityProfileOnXoo1 = new QProfileDto()
+ .setKee("sonar-way-xoo1-12345")
+ .setRulesProfileUuid("rp-sonar-way-xoo1-12345")
.setOrganizationUuid(orgUuid)
.setLanguage(xoo1.getKey())
.setName("Sonar way");
- QProfileDto qualityProfileOnXoo2 = QProfileDto.createFor("sonar-way-xoo2-12345")
+ QProfileDto qualityProfileOnXoo2 = new QProfileDto()
+ .setKee("sonar-way-xoo2-12345")
+ .setRulesProfileUuid("rp-sonar-way-xoo2-12345")
.setOrganizationUuid(orgUuid)
.setLanguage(xoo2.getKey())
.setName("Sonar way");
- QProfileDto anotherQualityProfileOnXoo1 = QProfileDto.createFor("sonar-way-xoo1-45678")
+ QProfileDto anotherQualityProfileOnXoo1 = new QProfileDto()
+ .setKee("sonar-way-xoo1-45678")
+ .setRulesProfileUuid("rp-sonar-way-xoo1-45678")
.setOrganizationUuid(orgUuid)
.setLanguage(xoo1.getKey())
.setName("Another way");
}
private QProfileDto createProfile(String keySuffix, Language language, OrganizationDto org, String name) {
- return QProfileDto.createFor(org.getKey() + "-" + keySuffix)
+ return new QProfileDto()
+ .setKee(org.getKey() + "-" + keySuffix)
+ .setRulesProfileUuid("rp-" + org.getKey() + "-" + keySuffix)
.setOrganizationUuid(org.getUuid())
.setLanguage(language.getKey())
.setName(name);
import org.sonar.db.qualityprofile.ActiveRuleDto;
import org.sonar.db.qualityprofile.ActiveRuleKey;
import org.sonar.db.qualityprofile.ActiveRuleParamDto;
+import org.sonar.db.qualityprofile.QProfileDto;
import org.sonar.db.rule.RuleDao;
import org.sonar.db.rule.RuleDefinitionDto;
import org.sonar.db.rule.RuleDto;
// Create a profile and activate rule
logInAsQProfileAdministrator();
- db.qualityProfileDao().insert(dbSession, QProfileTesting.newXooP1("org-123"));
+ QProfileDto profile = QProfileTesting.newXooP1("org-123");
+ db.qualityProfileDao().insert(dbSession, profile);
dbSession.commit();
dbSession.clearCache();
RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1);
- TESTER.get(RuleActivator.class).activate(dbSession, activation, QProfileTesting.XOO_P1_KEY);
+ TESTER.get(RuleActivator.class).activate(dbSession, activation, profile);
// Restart, repo xoo still exists -> deactivate x1
register(new Rules() {
});
assertThat(ruleIndex.search(new RuleQuery().setKey(RuleTesting.XOO_X1.toString()), new SearchOptions()).getTotal()).isEqualTo(0);
assertThat(ruleIndex.search(new RuleQuery().setKey(RuleTesting.XOO_X2.toString()), new SearchOptions()).getTotal()).isEqualTo(1);
- assertThat(ruleIndex.search(new RuleQuery().setActivation(true), new SearchOptions()).getIds()).isEmpty();
- assertThat(db.activeRuleDao().selectByProfileKey(dbSession, QProfileTesting.XOO_P1_KEY)).isEmpty();
+ assertThat(ruleIndex.search(new RuleQuery().setActivation(true).setQProfile(profile), new SearchOptions()).getIds()).isEmpty();
+ assertThat(db.activeRuleDao().selectByProfileUuid(dbSession, QProfileTesting.XOO_P1_KEY)).isEmpty();
}
@Test
// create a profile and activate rule
logInAsQProfileAdministrator();
- db.qualityProfileDao().insert(dbSession, QProfileTesting.newXooP1("org-123"));
+ QProfileDto profile = QProfileTesting.newXooP1("org-123");
+ db.qualityProfileDao().insert(dbSession, profile);
dbSession.commit();
dbSession.clearCache();
RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1);
- TESTER.get(RuleActivator.class).activate(dbSession, activation, QProfileTesting.XOO_P1_KEY);
+ TESTER.get(RuleActivator.class).activate(dbSession, activation, profile);
dbSession.commit();
// Restart without xoo
dbSession.clearCache();
assertThat(ruleIndex.search(new RuleQuery().setKey(RuleTesting.XOO_X1.toString()), new SearchOptions()).getTotal()).isEqualTo(0);
- assertThat(db.activeRuleDao().selectByProfileKey(dbSession, QProfileTesting.XOO_P1_KEY)).isEmpty();
+ assertThat(db.activeRuleDao().selectByProfileUuid(dbSession, QProfileTesting.XOO_P1_KEY)).isEmpty();
// Re-install
register(rules);
assertThat(ruleIndex.search(new RuleQuery().setKey(RuleTesting.XOO_X1.toString()), new SearchOptions()).getTotal()).isEqualTo(1);
- assertThat(db.activeRuleDao().selectByProfileKey(dbSession, QProfileTesting.XOO_P1_KEY)).hasSize(1);
+ assertThat(db.activeRuleDao().selectByProfileUuid(dbSession, QProfileTesting.XOO_P1_KEY)).hasSize(1);
}
@Test
// Create profile and activate rule
logInAsQProfileAdministrator();
- db.qualityProfileDao().insert(dbSession, QProfileTesting.newXooP1("org-123"));
+ QProfileDto profile = QProfileTesting.newXooP1("org-123");
+ db.qualityProfileDao().insert(dbSession, profile);
dbSession.commit();
dbSession.clearCache();
RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1);
activation.setParameter("format", "txt");
- TESTER.get(RuleActivator.class).activate(dbSession, activation, QProfileTesting.XOO_P1_KEY);
+ TESTER.get(RuleActivator.class).activate(dbSession, activation, profile);
dbSession.commit();
// Default value of "min" is changed, "format" is removed, "format2" is added, "max" is added with a default value
}
});
- ActiveRuleDto activeRuleDto = db.activeRuleDao().selectOrFailByKey(dbSession, ActiveRuleKey.of(QProfileTesting.XOO_P1_KEY, RuleTesting.XOO_X1));
+ ActiveRuleDto activeRuleDto = db.activeRuleDao().selectByKey(dbSession, ActiveRuleKey.of(profile, RuleTesting.XOO_X1)).get();
List<ActiveRuleParamDto> params = db.activeRuleDao().selectParamsByActiveRuleId(dbSession, activeRuleDto.getId());
assertThat(params).hasSize(2);
import org.sonar.server.organization.TestOrganizationFlags;
import org.sonar.server.qualityprofile.RuleActivator;
import org.sonar.server.qualityprofile.index.ActiveRuleIndexer;
+import org.sonar.server.qualityprofile.index.ActiveRuleIteratorFactory;
import org.sonar.server.rule.index.RuleIndex;
import org.sonar.server.rule.index.RuleIndexDefinition;
import org.sonar.server.rule.index.RuleIndexer;
when(system.now()).thenReturn(DATE1.getTime());
ruleIndexer = new RuleIndexer(esTester.client(), dbClient);
ruleIndex = new RuleIndex(esTester.client());
- activeRuleIndexer = new ActiveRuleIndexer(system, dbClient, esTester.client());
+ activeRuleIndexer = new ActiveRuleIndexer(dbClient, esTester.client(), new ActiveRuleIteratorFactory(dbClient));
defaultOrganization = dbTester.getDefaultOrganization();
}
assertThat(paramsByKey.get("format").getDefaultValue()).isNull();
// Verify that severity has not changed
- ActiveRuleDto activeRuleReloaded = db.getDbClient().activeRuleDao().selectOrFailByKey(dbSession, ActiveRuleKey.of(profileDto.getKee(), customRule.getKey()));
+ ActiveRuleDto activeRuleReloaded = db.getDbClient().activeRuleDao().selectByKey(dbSession, ActiveRuleKey.of(profileDto, customRule.getKey())).get();
assertThat(activeRuleReloaded.getSeverityString()).isEqualTo(Severity.BLOCKER);
// Verify active rule parameters has been updated
+++ /dev/null
-/*
- * SonarQube
- * Copyright (C) 2009-2017 SonarSource SA
- * mailto:info AT sonarsource DOT com
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 3 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-package org.sonar.server.rule.index;
-
-import com.google.common.collect.Maps;
-import org.sonar.api.rule.RuleKey;
-import org.sonar.api.rule.RuleStatus;
-import org.sonar.api.rule.Severity;
-import org.sonar.api.rules.RuleType;
-import org.sonar.db.rule.RuleTesting;
-
-public class RuleDocTesting {
-
- public static RuleDoc newDoc() {
- return newDoc(RuleTesting.XOO_X1);
- }
-
- public static RuleDoc newDoc(RuleKey ruleKey) {
- return new RuleDoc(Maps.<String, Object>newHashMap())
- .setKey(ruleKey.toString())
- .setRepository(ruleKey.repository())
- .setRuleKey(ruleKey.rule())
- .setName("Name " + ruleKey.toString())
- .setHtmlDescription("Description " + ruleKey.rule())
- .setSeverity(Severity.CRITICAL)
- .setStatus(RuleStatus.READY.name())
- .setLanguage("xoo")
- .setIsTemplate(false)
- .setType(RuleType.CODE_SMELL)
- .setCreatedAt(1_500_000_000L)
- .setUpdatedAt(1_600_000_000L);
- }
-}
public class RuleIndexDefinitionTest {
- Settings settings = new MapSettings();
- RuleIndexDefinition underTest = new RuleIndexDefinition(settings);
+ private Settings settings = new MapSettings();
+ private RuleIndexDefinition underTest = new RuleIndexDefinition(settings);
@Rule
public EsTester tester = new EsTester(underTest);
package org.sonar.server.rule.index;
import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Sets;
+import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
import org.sonar.api.rule.RuleKey;
import org.sonar.api.rule.RuleStatus;
import org.sonar.api.utils.System2;
+import org.sonar.api.utils.internal.AlwaysIncreasingSystem2;
import org.sonar.db.DbTester;
import org.sonar.db.organization.OrganizationDto;
-import org.sonar.db.qualityprofile.ActiveRuleKey;
+import org.sonar.db.qualityprofile.QProfileDto;
import org.sonar.db.rule.RuleDefinitionDto;
import org.sonar.db.rule.RuleMetadataDto;
import org.sonar.server.es.EsTester;
+import org.sonar.server.es.Facets;
import org.sonar.server.es.SearchIdResult;
import org.sonar.server.es.SearchOptions;
-import org.sonar.server.qualityprofile.index.ActiveRuleDoc;
-import org.sonar.server.qualityprofile.index.ActiveRuleDocTesting;
import org.sonar.server.qualityprofile.index.ActiveRuleIndexer;
+import org.sonar.server.qualityprofile.index.ActiveRuleIteratorFactory;
import static com.google.common.collect.ImmutableSet.of;
import static java.util.Arrays.asList;
import static java.util.Collections.emptySet;
import static java.util.Collections.singletonList;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.guava.api.Assertions.entry;
+import static org.assertj.core.api.Assertions.entry;
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.db.rule.RuleTesting.setIsTemplate;
import static org.sonar.db.rule.RuleTesting.setLanguage;
import static org.sonar.db.rule.RuleTesting.setName;
-import static org.sonar.db.rule.RuleTesting.setOrganizationUuid;
+import static org.sonar.db.rule.RuleTesting.setOrganization;
import static org.sonar.db.rule.RuleTesting.setRepositoryKey;
import static org.sonar.db.rule.RuleTesting.setRuleKey;
import static org.sonar.db.rule.RuleTesting.setSeverity;
import static org.sonar.server.rule.index.RuleIndex.FACET_TAGS;
import static org.sonar.server.rule.index.RuleIndex.FACET_TYPES;
import static org.sonar.server.rule.index.RuleIndexDefinition.INDEX_TYPE_ACTIVE_RULE;
+import static org.sonar.server.rule.index.RuleIndexDefinition.INDEX_TYPE_RULE;
+import static org.sonar.server.rule.index.RuleIndexDefinition.INDEX_TYPE_RULE_EXTENSION;
public class RuleIndexTest {
- private static final String QUALITY_PROFILE_KEY1 = "qp1";
- private static final String QUALITY_PROFILE_KEY2 = "qp2";
-
- private System2 system2 = System2.INSTANCE;
+ private System2 system2 = new AlwaysIncreasingSystem2();
@Rule
- public EsTester tester = new EsTester(new RuleIndexDefinition(new MapSettings()));
+ public EsTester es = new EsTester(RuleIndexDefinition.createForTest(new MapSettings()));
@Rule
- public DbTester dbTester = DbTester.create(system2);
+ public DbTester db = DbTester.create(system2);
@Rule
public ExpectedException thrown = ExpectedException.none();
- private RuleIndex index;
+ private RuleIndex underTest;
private RuleIndexer ruleIndexer;
private ActiveRuleIndexer activeRuleIndexer;
@Before
public void setUp() {
- ruleIndexer = new RuleIndexer(tester.client(), dbTester.getDbClient());
- activeRuleIndexer = new ActiveRuleIndexer(system2, dbTester.getDbClient(), tester.client());
- index = new RuleIndex(tester.client());
+ ruleIndexer = new RuleIndexer(es.client(), db.getDbClient());
+ activeRuleIndexer = new ActiveRuleIndexer(db.getDbClient(), es.client(), new ActiveRuleIteratorFactory(db.getDbClient()));
+ underTest = new RuleIndex(es.client());
}
@Test
public void search_all_rules() {
createRule();
createRule();
+ index();
- SearchIdResult results = index.search(new RuleQuery(), new SearchOptions());
+ SearchIdResult results = underTest.search(new RuleQuery(), new SearchOptions());
assertThat(results.getTotal()).isEqualTo(2);
assertThat(results.getIds()).hasSize(2);
RuleDefinitionDto php2 = createRule(
setRepositoryKey("php"),
setRuleKey("S002"));
+ index();
// key
RuleQuery query = new RuleQuery().setQueryText("X001");
- assertThat(index.search(query, new SearchOptions()).getIds()).containsOnly(js1.getKey(), cobol1.getKey());
+ assertThat(underTest.search(query, new SearchOptions()).getIds()).containsOnly(js1.getKey(), cobol1.getKey());
// partial key does not match
query = new RuleQuery().setQueryText("X00");
- assertThat(index.search(query, new SearchOptions()).getIds()).isEmpty();
+ assertThat(underTest.search(query, new SearchOptions()).getIds()).isEmpty();
// repo:key -> nice-to-have !
query = new RuleQuery().setQueryText("javascript:X001");
- assertThat(index.search(query, new SearchOptions()).getIds()).containsOnly(js1.getKey());
+ assertThat(underTest.search(query, new SearchOptions()).getIds()).containsOnly(js1.getKey());
}
@Test
RuleDefinitionDto ruleDto = createRule(
setRepositoryKey("javascript"),
setRuleKey("X001"));
+ index();
RuleQuery query = new RuleQuery().setQueryText("x001");
- assertThat(index.search(query, new SearchOptions()).getIds()).containsOnly(ruleDto.getKey());
+ assertThat(underTest.search(query, new SearchOptions()).getIds()).containsOnly(ruleDto.getKey());
}
@Test
createRule(
setRepositoryKey("php"),
setRuleKey("S002"));
+ index();
// key
RuleQuery query = new RuleQuery().setKey(RuleKey.of("javascript", "X001").toString());
- assertThat(index.search(query, new SearchOptions()).getIds()).hasSize(1);
+ assertThat(underTest.search(query, new SearchOptions()).getIds()).hasSize(1);
// partial key does not match
query = new RuleQuery().setKey("X001");
- assertThat(index.search(query, new SearchOptions()).getIds()).isEmpty();
+ assertThat(underTest.search(query, new SearchOptions()).getIds()).isEmpty();
}
@Test
public void search_name_by_query() {
createRule(setName("testing the partial match and matching of rule"));
+ index();
// substring
RuleQuery query = new RuleQuery().setQueryText("test");
- assertThat(index.search(query, new SearchOptions()).getIds()).hasSize(1);
+ assertThat(underTest.search(query, new SearchOptions()).getIds()).hasSize(1);
// substring
query = new RuleQuery().setQueryText("partial match");
- assertThat(index.search(query, new SearchOptions()).getIds()).hasSize(1);
+ assertThat(underTest.search(query, new SearchOptions()).getIds()).hasSize(1);
// case-insensitive
query = new RuleQuery().setQueryText("TESTING");
- assertThat(index.search(query, new SearchOptions()).getIds()).hasSize(1);
+ assertThat(underTest.search(query, new SearchOptions()).getIds()).hasSize(1);
// not found
query = new RuleQuery().setQueryText("not present");
- assertThat(index.search(query, new SearchOptions()).getIds()).isEmpty();
+ assertThat(underTest.search(query, new SearchOptions()).getIds()).isEmpty();
}
@Test
public void search_name_with_protected_chars() {
- String nameWithProtectedChars = "ja#va&sc\"r:ipt";
-
- RuleDefinitionDto ruleDto = createRule(setName(nameWithProtectedChars));
+ RuleDefinitionDto rule = createRule(setName("ja#va&sc\"r:ipt"));
+ index();
- RuleQuery protectedCharsQuery = new RuleQuery().setQueryText(nameWithProtectedChars);
- List<RuleKey> results = index.search(protectedCharsQuery, new SearchOptions()).getIds();
- assertThat(results).containsOnly(ruleDto.getKey());
+ RuleQuery protectedCharsQuery = new RuleQuery().setQueryText(rule.getName());
+ List<RuleKey> results = underTest.search(protectedCharsQuery, new SearchOptions()).getIds();
+ assertThat(results).containsOnly(rule.getKey());
}
@Test
RuleDefinitionDto pmd = createRule(
setRepositoryKey("pmd"),
setRuleKey("S002"));
+ index();
RuleQuery query = new RuleQuery().setRepositories(asList("checkstyle", "pmd"));
- SearchIdResult results = index.search(query, new SearchOptions());
- assertThat(results.getIds()).containsOnly(pmd.getKey());
+ SearchIdResult results = underTest.search(query, new SearchOptions());
+ assertThat(results.getIds()).containsExactly(pmd.getKey());
// no results
query = new RuleQuery().setRepositories(singletonList("checkstyle"));
- assertThat(index.search(query, new SearchOptions()).getIds()).isEmpty();
+ assertThat(underTest.search(query, new SearchOptions()).getIds()).isEmpty();
// empty list => no filter
query = new RuleQuery().setRepositories(emptyList());
- assertThat(index.search(query, new SearchOptions()).getIds()).containsOnly(findbugs.getKey(), pmd.getKey());
+ assertThat(underTest.search(query, new SearchOptions()).getIds()).containsOnly(findbugs.getKey(), pmd.getKey());
}
@Test
public void filter_by_tags() {
- OrganizationDto organization = dbTester.organizations().insert();
+ OrganizationDto organization = db.organizations().insert();
RuleDefinitionDto rule1 = createRule(setSystemTags("tag1s"));
createRuleMetadata(rule1, organization, setTags("tag1"));
RuleDefinitionDto rule2 = createRule(setSystemTags("tag2s"));
createRuleMetadata(rule2, organization, setTags("tag2"));
+ index();
- // find all
- RuleQuery query = new RuleQuery();
- assertThat(index.search(query, new SearchOptions()).getIds()).containsOnly(rule1.getKey(), rule2.getKey());
-
+ assertThat(es.countDocuments(INDEX_TYPE_RULE_EXTENSION)).isEqualTo(4);
// tag2s in filter
- query = new RuleQuery().setOrganizationUuid(organization.getUuid()).setTags(of("tag2s"));
- assertThat(index.search(query, new SearchOptions()).getIds()).containsOnly(rule2.getKey());
+ RuleQuery query = new RuleQuery().setOrganization(organization).setTags(of("tag2s"));
+ verifySearch(query, rule2);
// tag2 in filter
- query = new RuleQuery().setOrganizationUuid(organization.getUuid()).setTags(of("tag2"));
- assertThat(index.search(query, new SearchOptions()).getIds()).containsOnly(rule2.getKey());
+ query = new RuleQuery().setOrganization(organization).setTags(of("tag2"));
+ verifySearch(query, rule2);
// empty list => no filter
query = new RuleQuery().setTags(emptySet());
- assertThat(index.search(query, new SearchOptions()).getIds()).containsOnly(rule1.getKey(), rule2.getKey());
+ verifySearch(query, rule1, rule2);
// null list => no filter
query = new RuleQuery().setTags(null);
- assertThat(index.search(query, new SearchOptions()).getIds()).containsOnly(rule1.getKey(), rule2.getKey());
- }
-
- @SafeVarargs
- private final RuleDefinitionDto createRule(Consumer<RuleDefinitionDto>... populaters) {
- RuleDefinitionDto ruleDto = dbTester.rules().insert(populaters);
- ruleIndexer.indexRuleDefinition(ruleDto.getKey());
- return ruleDto;
- }
-
- @SafeVarargs
- private final RuleMetadataDto createRuleMetadata(RuleDefinitionDto rule, OrganizationDto organization, Consumer<RuleMetadataDto>... populaters) {
- RuleMetadataDto ruleMetadataDto = dbTester.rules().insertOrUpdateMetadata(rule, organization, populaters);
- ruleIndexer.indexRuleExtension(organization, rule.getKey());
- return ruleMetadataDto;
+ verifySearch(query, rule1, rule2);
}
@Test
public void tags_facet_supports_selected_value_with_regexp_special_characters() {
- OrganizationDto organization = dbTester.organizations().insert();
+ OrganizationDto organization = db.organizations().insert();
RuleDefinitionDto rule = createRule();
createRuleMetadata(rule, organization, setTags("misra++"));
+ index();
RuleQuery query = new RuleQuery()
- .setOrganizationUuid(organization.getUuid())
+ .setOrganization(organization)
.setTags(singletonList("misra["));
SearchOptions options = new SearchOptions().addFacets(FACET_TAGS);
// do not fail
- assertThat(index.search(query, options).getTotal()).isEqualTo(0);
+ assertThat(underTest.search(query, options).getTotal()).isEqualTo(0);
}
@Test
RuleDefinitionDto vulnerability = createRule(setType(VULNERABILITY));
RuleDefinitionDto bug1 = createRule(setType(BUG));
RuleDefinitionDto bug2 = createRule(setType(BUG));
+ index();
// find all
RuleQuery query = new RuleQuery();
- assertThat(index.search(query, new SearchOptions()).getIds()).hasSize(4);
+ assertThat(underTest.search(query, new SearchOptions()).getIds()).hasSize(4);
// type3 in filter
query = new RuleQuery().setTypes(of(VULNERABILITY));
- assertThat(index.search(query, new SearchOptions()).getIds()).containsOnly(vulnerability.getKey());
+ assertThat(underTest.search(query, new SearchOptions()).getIds()).containsOnly(vulnerability.getKey());
query = new RuleQuery().setTypes(of(BUG));
- assertThat(index.search(query, new SearchOptions()).getIds()).containsOnly(bug1.getKey(), bug2.getKey());
+ assertThat(underTest.search(query, new SearchOptions()).getIds()).containsOnly(bug1.getKey(), bug2.getKey());
// types in query => nothing
query = new RuleQuery().setQueryText("code smell bug vulnerability");
- assertThat(index.search(query, new SearchOptions()).getIds()).isEmpty();
+ assertThat(underTest.search(query, new SearchOptions()).getIds()).isEmpty();
// null list => no filter
query = new RuleQuery().setTypes(emptySet());
- assertThat(index.search(query, new SearchOptions()).getIds()).hasSize(4);
+ assertThat(underTest.search(query, new SearchOptions()).getIds()).hasSize(4);
// null list => no filter
query = new RuleQuery().setTypes(null);
- assertThat(index.search(query, new SearchOptions()).getIds()).hasSize(4);
+ assertThat(underTest.search(query, new SearchOptions()).getIds()).hasSize(4);
}
@Test
public void search_by_is_template() {
RuleDefinitionDto ruleNoTemplate = createRule(setIsTemplate(false));
RuleDefinitionDto ruleIsTemplate = createRule(setIsTemplate(true));
+ index();
// find all
RuleQuery query = new RuleQuery();
- SearchIdResult results = index.search(query, new SearchOptions());
+ SearchIdResult results = underTest.search(query, new SearchOptions());
assertThat(results.getIds()).hasSize(2);
// Only template
query = new RuleQuery().setIsTemplate(true);
- results = index.search(query, new SearchOptions());
+ results = underTest.search(query, new SearchOptions());
assertThat(results.getIds()).containsOnly(ruleIsTemplate.getKey());
// Only not template
query = new RuleQuery().setIsTemplate(false);
- results = index.search(query, new SearchOptions());
+ results = underTest.search(query, new SearchOptions());
assertThat(results.getIds()).containsOnly(ruleNoTemplate.getKey());
// null => no filter
query = new RuleQuery().setIsTemplate(null);
- results = index.search(query, new SearchOptions());
+ results = underTest.search(query, new SearchOptions());
assertThat(results.getIds()).containsOnly(ruleIsTemplate.getKey(), ruleNoTemplate.getKey());
}
public void search_by_template_key() {
RuleDefinitionDto template = createRule(setIsTemplate(true));
RuleDefinitionDto customRule = createRule(setTemplateId(template.getId()));
+ index();
// find all
RuleQuery query = new RuleQuery();
- SearchIdResult results = index.search(query, new SearchOptions());
+ SearchIdResult results = underTest.search(query, new SearchOptions());
assertThat(results.getIds()).hasSize(2);
// Only custom rule
query = new RuleQuery().setTemplateKey(template.getKey().toString());
- results = index.search(query, new SearchOptions());
+ results = underTest.search(query, new SearchOptions());
assertThat(results.getIds()).containsOnly(customRule.getKey());
// null => no filter
query = new RuleQuery().setTemplateKey(null);
- assertThat(index.search(query, new SearchOptions()).getIds()).hasSize(2);
+ assertThat(underTest.search(query, new SearchOptions()).getIds()).hasSize(2);
}
@Test
public void search_by_any_of_languages() {
RuleDefinitionDto java = createRule(setLanguage("java"));
RuleDefinitionDto javascript = createRule(setLanguage("js"));
+ index();
RuleQuery query = new RuleQuery().setLanguages(asList("cobol", "js"));
- SearchIdResult results = index.search(query, new SearchOptions());
+ SearchIdResult results = underTest.search(query, new SearchOptions());
assertThat(results.getIds()).containsOnly(javascript.getKey());
// no results
query = new RuleQuery().setLanguages(singletonList("cpp"));
- assertThat(index.search(query, new SearchOptions()).getIds()).isEmpty();
+ assertThat(underTest.search(query, new SearchOptions()).getIds()).isEmpty();
// empty list => no filter
query = new RuleQuery().setLanguages(emptyList());
- assertThat(index.search(query, new SearchOptions()).getIds()).hasSize(2);
+ assertThat(underTest.search(query, new SearchOptions()).getIds()).hasSize(2);
// null list => no filter
query = new RuleQuery().setLanguages(null);
- assertThat(index.search(query, new SearchOptions()).getIds()).hasSize(2);
+ assertThat(underTest.search(query, new SearchOptions()).getIds()).hasSize(2);
+ }
+
+ @SafeVarargs
+ private final RuleDefinitionDto createRule(Consumer<RuleDefinitionDto>... consumers) {
+ return db.rules().insert(consumers);
+ }
+
+ private RuleDefinitionDto createJavaRule() {
+ return createRule(r -> r.setLanguage("java"));
+ }
+
+ @SafeVarargs
+ private final RuleMetadataDto createRuleMetadata(RuleDefinitionDto rule, OrganizationDto organization, Consumer<RuleMetadataDto>... populaters) {
+ return db.rules().insertOrUpdateMetadata(rule, organization, populaters);
}
@Test
public void search_by_any_of_severities() {
RuleDefinitionDto blocker = createRule(setSeverity(BLOCKER));
RuleDefinitionDto info = createRule(setSeverity(INFO));
+ index();
RuleQuery query = new RuleQuery().setSeverities(asList(INFO, MINOR));
- SearchIdResult results = index.search(query, new SearchOptions());
+ SearchIdResult results = underTest.search(query, new SearchOptions());
assertThat(results.getIds()).containsOnly(info.getKey());
// no results
query = new RuleQuery().setSeverities(singletonList(MINOR));
- assertThat(index.search(query, new SearchOptions()).getIds()).isEmpty();
+ assertThat(underTest.search(query, new SearchOptions()).getIds()).isEmpty();
// empty list => no filter
query = new RuleQuery().setSeverities(emptyList());
- assertThat(index.search(query, new SearchOptions()).getIds()).hasSize(2);
+ assertThat(underTest.search(query, new SearchOptions()).getIds()).hasSize(2);
// null list => no filter
query = new RuleQuery().setSeverities();
- assertThat(index.search(query, new SearchOptions()).getIds()).hasSize(2);
+ assertThat(underTest.search(query, new SearchOptions()).getIds()).hasSize(2);
}
@Test
public void search_by_any_of_statuses() {
RuleDefinitionDto beta = createRule(setStatus(RuleStatus.BETA));
RuleDefinitionDto ready = createRule(setStatus(RuleStatus.READY));
+ index();
RuleQuery query = new RuleQuery().setStatuses(asList(RuleStatus.DEPRECATED, RuleStatus.READY));
- SearchIdResult<RuleKey> results = index.search(query, new SearchOptions());
+ SearchIdResult<RuleKey> results = underTest.search(query, new SearchOptions());
assertThat(results.getIds()).containsOnly(ready.getKey());
// no results
query = new RuleQuery().setStatuses(singletonList(RuleStatus.DEPRECATED));
- assertThat(index.search(query, new SearchOptions()).getIds()).isEmpty();
+ assertThat(underTest.search(query, new SearchOptions()).getIds()).isEmpty();
// empty list => no filter
query = new RuleQuery().setStatuses(emptyList());
- assertThat(index.search(query, new SearchOptions()).getIds()).hasSize(2);
+ assertThat(underTest.search(query, new SearchOptions()).getIds()).hasSize(2);
// null list => no filter
query = new RuleQuery().setStatuses(null);
- assertThat(index.search(query, new SearchOptions()).getIds()).hasSize(2);
+ assertThat(underTest.search(query, new SearchOptions()).getIds()).hasSize(2);
}
@Test
- public void search_by_profile() throws InterruptedException {
- RuleDefinitionDto rule1 = createRule();
- RuleDefinitionDto rule2 = createRule();
- RuleDefinitionDto rule3 = createRule();
+ public void activation_parameter_is_ignored_if_profile_is_not_set() {
+ RuleDefinitionDto rule1 = createJavaRule();
+ RuleDefinitionDto rule2 = createJavaRule();
+ QProfileDto profile1 = createJavaProfile();
+ db.qualityProfiles().activateRule(profile1, rule1);
+ index();
+
+ // all rules are returned
+ verifySearch(newRuleQuery().setActivation(true), rule1, rule2);
+ }
- indexActiveRules(
- ActiveRuleDocTesting.newDoc(ActiveRuleKey.of(QUALITY_PROFILE_KEY1, rule1.getKey())),
- ActiveRuleDocTesting.newDoc(ActiveRuleKey.of(QUALITY_PROFILE_KEY2, rule1.getKey())),
- ActiveRuleDocTesting.newDoc(ActiveRuleKey.of(QUALITY_PROFILE_KEY1, rule2.getKey())));
+ @Test
+ public void search_by_activation() {
+ RuleDefinitionDto rule1 = createJavaRule();
+ RuleDefinitionDto rule2 = createJavaRule();
+ RuleDefinitionDto rule3 = createJavaRule();
+ QProfileDto profile1 = createJavaProfile();
+ QProfileDto profile2 = createJavaProfile();
+ db.qualityProfiles().activateRule(profile1, rule1);
+ db.qualityProfiles().activateRule(profile2, rule1);
+ db.qualityProfiles().activateRule(profile1, rule2);
+ index();
- assertThat(tester.countDocuments(INDEX_TYPE_ACTIVE_RULE)).isEqualTo(3);
+ // active rules
+ verifySearch(newRuleQuery().setActivation(true).setQProfile(profile1), rule1, rule2);
+ verifySearch(newRuleQuery().setActivation(true).setQProfile(profile2), rule1);
- // 1. get all active rules.
- assertThat(index.search(new RuleQuery().setActivation(true), new SearchOptions()).getIds())
- .containsOnly(rule1.getKey(), rule2.getKey());
+ // inactive rules
+ verifySearch(newRuleQuery().setActivation(false).setQProfile(profile1), rule3);
+ verifySearch(newRuleQuery().setActivation(false).setQProfile(profile2), rule2, rule3);
+ }
- // 2. get all inactive rules.
- assertThat(index.search(new RuleQuery().setActivation(false), new SearchOptions()).getIds())
- .containsOnly(rule3.getKey());
+ private void verifyEmptySearch(RuleQuery query) {
+ verifySearch(query);
+ }
- // 3. get all rules not active on profile
- assertThat(index.search(new RuleQuery().setActivation(false).setQProfileKey(QUALITY_PROFILE_KEY2), new SearchOptions()).getIds())
- .containsOnly(rule2.getKey(), rule3.getKey());
+ private void verifySearch(RuleQuery query, RuleDefinitionDto... expectedRules) {
+ SearchIdResult<RuleKey> result = underTest.search(query, new SearchOptions());
+ assertThat(result.getTotal()).isEqualTo((long) expectedRules.length);
+ assertThat(result.getIds()).hasSize(expectedRules.length);
+ for (RuleDefinitionDto expectedRule : expectedRules) {
+ assertThat(result.getIds()).contains(expectedRule.getKey());
+ }
+ }
- // 4. get all active rules on profile
- assertThat(index.search(new RuleQuery().setActivation(true).setQProfileKey(QUALITY_PROFILE_KEY2), new SearchOptions()).getIds())
- .containsOnly(rule1.getKey());
+ private void index() {
+ ruleIndexer.indexOnStartup(Sets.newHashSet(INDEX_TYPE_RULE, INDEX_TYPE_RULE_EXTENSION));
+ activeRuleIndexer.indexOnStartup(Sets.newHashSet(INDEX_TYPE_ACTIVE_RULE));
+ }
+
+ private RuleQuery newRuleQuery() {
+ return new RuleQuery().setOrganization(db.getDefaultOrganization());
+ }
+
+ private QProfileDto createJavaProfile() {
+ return db.qualityProfiles().insert(db.getDefaultOrganization(), p -> p.setLanguage("java"));
+ }
+
+ private QProfileDto createProfile(OrganizationDto organization) {
+ return db.qualityProfiles().insert(organization);
}
@Test
- public void search_by_profile_and_inheritance() {
- RuleDefinitionDto rule1 = createRule();
- RuleDefinitionDto rule2 = createRule();
- RuleDefinitionDto rule3 = createRule();
- RuleDefinitionDto rule4 = createRule();
-
- ActiveRuleKey activeRuleKey1 = ActiveRuleKey.of(QUALITY_PROFILE_KEY1, rule1.getKey());
- ActiveRuleKey activeRuleKey2 = ActiveRuleKey.of(QUALITY_PROFILE_KEY1, rule2.getKey());
- ActiveRuleKey activeRuleKey3 = ActiveRuleKey.of(QUALITY_PROFILE_KEY1, rule3.getKey());
-
- indexActiveRules(
- ActiveRuleDocTesting.newDoc(activeRuleKey1),
- ActiveRuleDocTesting.newDoc(activeRuleKey2),
- ActiveRuleDocTesting.newDoc(activeRuleKey3),
- // Profile 2 is a child a profile 1
- ActiveRuleDocTesting.newDoc(ActiveRuleKey.of(QUALITY_PROFILE_KEY2, rule1.getKey())).setInheritance(INHERITED.name()),
- ActiveRuleDocTesting.newDoc(ActiveRuleKey.of(QUALITY_PROFILE_KEY2, rule2.getKey())).setInheritance(OVERRIDES.name()),
- ActiveRuleDocTesting.newDoc(ActiveRuleKey.of(QUALITY_PROFILE_KEY2, rule3.getKey())).setInheritance(INHERITED.name()));
-
- // 0. get all rules
- assertThat(index.search(new RuleQuery(), new SearchOptions()).getIds())
- .hasSize(4);
-
- // 1. get all active rules
- assertThat(index.search(new RuleQuery()
- .setActivation(true), new SearchOptions()).getIds())
- .hasSize(3);
-
- // 2. get all inactive rules.
- assertThat(index.search(new RuleQuery()
- .setActivation(false), new SearchOptions()).getIds())
- .containsOnly(rule4.getKey());
-
- // 3. get Inherited Rules on profile1
- assertThat(index.search(new RuleQuery().setActivation(true)
- .setQProfileKey(QUALITY_PROFILE_KEY1)
- .setInheritance(of(INHERITED.name())),
- new SearchOptions()).getIds())
- .isEmpty();
-
- // 4. get Inherited Rules on profile2
- assertThat(index.search(new RuleQuery().setActivation(true)
- .setQProfileKey(QUALITY_PROFILE_KEY2)
- .setInheritance(of(INHERITED.name())),
- new SearchOptions()).getIds())
- .hasSize(2);
-
- // 5. get Overridden Rules on profile1
- assertThat(index.search(new RuleQuery().setActivation(true)
- .setQProfileKey(QUALITY_PROFILE_KEY1)
- .setInheritance(of(OVERRIDES.name())),
- new SearchOptions()).getIds())
- .isEmpty();
-
- // 6. get Overridden Rules on profile2
- assertThat(index.search(new RuleQuery().setActivation(true)
- .setQProfileKey(QUALITY_PROFILE_KEY2)
- .setInheritance(of(OVERRIDES.name())),
- new SearchOptions()).getIds())
- .hasSize(1);
-
- // 7. get Inherited AND Overridden Rules on profile1
- assertThat(index.search(new RuleQuery().setActivation(true)
- .setQProfileKey(QUALITY_PROFILE_KEY1)
- .setInheritance(of(INHERITED.name(), OVERRIDES.name())),
- new SearchOptions()).getIds())
- .isEmpty();
-
- // 8. get Inherited AND Overridden Rules on profile2
- assertThat(index.search(new RuleQuery().setActivation(true)
- .setQProfileKey(QUALITY_PROFILE_KEY2)
- .setInheritance(of(INHERITED.name(), OVERRIDES.name())),
- new SearchOptions()).getIds())
- .hasSize(3);
+ public void search_by_activation_and_inheritance() {
+ RuleDefinitionDto rule1 = createJavaRule();
+ RuleDefinitionDto rule2 = createJavaRule();
+ RuleDefinitionDto rule3 = createJavaRule();
+ RuleDefinitionDto rule4 = createJavaRule();
+ QProfileDto parent = createJavaProfile();
+ QProfileDto child = createJavaProfile();
+ db.qualityProfiles().activateRule(parent, rule1);
+ db.qualityProfiles().activateRule(parent, rule2);
+ db.qualityProfiles().activateRule(parent, rule3);
+ db.qualityProfiles().activateRule(child, rule1, ar -> ar.setInheritance(INHERITED.name()));
+ db.qualityProfiles().activateRule(child, rule2, ar -> ar.setInheritance(OVERRIDES.name()));
+ db.qualityProfiles().activateRule(child, rule3, ar -> ar.setInheritance(INHERITED.name()));
+ index();
+
+ // all rules
+ verifySearch(newRuleQuery(), rule1, rule2, rule3, rule4);
+
+ // inherited/overrides rules on parent
+ verifyEmptySearch(newRuleQuery().setActivation(true).setQProfile(parent).setInheritance(of(INHERITED.name())));
+ verifyEmptySearch(newRuleQuery().setActivation(true).setQProfile(parent).setInheritance(of(OVERRIDES.name())));
+
+ // inherited/overrides rules on child
+ verifySearch(newRuleQuery().setActivation(true).setQProfile(child).setInheritance(of(INHERITED.name())), rule1, rule3);
+ verifySearch(newRuleQuery().setActivation(true).setQProfile(child).setInheritance(of(OVERRIDES.name())), rule2);
+
+ // inherited AND overridden on parent
+ verifyEmptySearch(newRuleQuery().setActivation(true).setQProfile(parent).setInheritance(of(INHERITED.name(), OVERRIDES.name())));
+
+ // inherited AND overridden on child
+ verifySearch(newRuleQuery().setActivation(true).setQProfile(child).setInheritance(of(INHERITED.name(), OVERRIDES.name())), rule1, rule2, rule3);
}
@Test
- public void search_by_profile_and_active_severity() {
+ public void search_by_activation_and_severity() {
RuleDefinitionDto major = createRule(setSeverity(MAJOR));
RuleDefinitionDto minor = createRule(setSeverity(MINOR));
RuleDefinitionDto info = createRule(setSeverity(INFO));
-
- indexActiveRules(
- ActiveRuleDocTesting.newDoc(ActiveRuleKey.of(QUALITY_PROFILE_KEY1, major.getKey())).setSeverity(BLOCKER),
- ActiveRuleDocTesting.newDoc(ActiveRuleKey.of(QUALITY_PROFILE_KEY2, major.getKey())).setSeverity(BLOCKER),
- ActiveRuleDocTesting.newDoc(ActiveRuleKey.of(QUALITY_PROFILE_KEY1, minor.getKey())).setSeverity(CRITICAL));
-
- // 1. get all active rules.
- assertThat(index.search(new RuleQuery().setActivation(true).setQProfileKey(QUALITY_PROFILE_KEY1), new SearchOptions()).getIds())
- .hasSize(2);
-
- // 2. get rules with active severity critical.
- SearchIdResult<RuleKey> result = index.search(new RuleQuery().setActivation(true)
- .setQProfileKey(QUALITY_PROFILE_KEY1).setActiveSeverities(singletonList(CRITICAL)),
- new SearchOptions().addFacets(singletonList(RuleIndex.FACET_ACTIVE_SEVERITIES)));
- assertThat(result.getIds()).containsOnly(minor.getKey());
+ QProfileDto profile1 = createJavaProfile();
+ QProfileDto profile2 = createJavaProfile();
+ db.qualityProfiles().activateRule(profile1, major, ar -> ar.setSeverity(BLOCKER));
+ db.qualityProfiles().activateRule(profile2, major, ar -> ar.setSeverity(BLOCKER));
+ db.qualityProfiles().activateRule(profile1, minor, ar -> ar.setSeverity(CRITICAL));
+ index();
+
+ // count activation severities of all active rules
+ RuleQuery query = newRuleQuery().setActivation(true).setQProfile(profile1);
+ verifySearch(query, major, minor);
+ verifyFacet(query, RuleIndex.FACET_ACTIVE_SEVERITIES, entry(BLOCKER, 1L), entry(CRITICAL, 1L));
// check stickyness of active severity facet
- assertThat(result.getFacets().get(RuleIndex.FACET_ACTIVE_SEVERITIES)).containsOnly(entry(BLOCKER, 1L), entry(CRITICAL, 1L));
+ query = newRuleQuery().setActivation(true).setQProfile(profile1).setActiveSeverities(singletonList(CRITICAL));
+ verifySearch(query, minor);
+ verifyFacet(query, RuleIndex.FACET_ACTIVE_SEVERITIES, entry(BLOCKER, 1L), entry(CRITICAL, 1L));
+ }
- // 3. count activation severities of all active rules
- result = index.search(new RuleQuery(), new SearchOptions().addFacets(singletonList(RuleIndex.FACET_ACTIVE_SEVERITIES)));
- assertThat(result.getIds()).hasSize(3);
- assertThat(result.getFacets().get(RuleIndex.FACET_ACTIVE_SEVERITIES)).containsOnly(entry(BLOCKER, 2L), entry(CRITICAL, 1L));
+ private void verifyFacet(RuleQuery query, String facet, Map.Entry<String, Long>... expectedBuckets) {
+ SearchIdResult<RuleKey> result = underTest.search(query, new SearchOptions().addFacets(facet));
+ assertThat(result.getFacets().get(facet))
+ .containsOnly(expectedBuckets);
}
@Test
public void listTags_should_return_both_system_tags_and_organization_specific_tags() {
- OrganizationDto organization = dbTester.organizations().insert();
+ OrganizationDto organization = db.organizations().insert();
RuleDefinitionDto rule1 = createRule(setSystemTags("sys1", "sys2"));
- createRuleMetadata(rule1, organization,
- setOrganizationUuid(organization.getUuid()),
- setTags("tag1"));
+ createRuleMetadata(rule1, organization, setOrganization(organization), setTags("tag1"));
RuleDefinitionDto rule2 = createRule(setSystemTags());
- createRuleMetadata(rule2, organization,
- setOrganizationUuid(organization.getUuid()),
- setTags("tag2"));
+ createRuleMetadata(rule2, organization, setOrganization(organization), setTags("tag2"));
- assertThat(index.listTags(organization, null, 10)).containsOnly("tag1", "tag2", "sys1", "sys2");
+ index();
+
+ assertThat(underTest.listTags(organization, null, 10)).containsOnly("tag1", "tag2", "sys1", "sys2");
}
@Test
public void listTags_must_not_return_tags_of_other_organizations() {
- OrganizationDto organization1 = dbTester.organizations().insert();
+ OrganizationDto organization1 = db.organizations().insert();
RuleDefinitionDto rule1 = createRule(setSystemTags("sys1"));
- createRuleMetadata(rule1, organization1,
- setOrganizationUuid(organization1.getUuid()),
- setTags("tag1"));
+ createRuleMetadata(rule1, organization1, setOrganization(organization1), setTags("tag1"));
- OrganizationDto organization2 = dbTester.organizations().insert();
+ OrganizationDto organization2 = db.organizations().insert();
RuleDefinitionDto rule2 = createRule(setSystemTags("sys2"));
- createRuleMetadata(rule2, organization2,
- setOrganizationUuid(organization2.getUuid()),
- setTags("tag2"));
+ createRuleMetadata(rule2, organization2, setOrganization(organization2), setTags("tag2"));
- OrganizationDto organization3 = dbTester.organizations().insert();
+ OrganizationDto organization3 = db.organizations().insert();
+ index();
- assertThat(index.listTags(organization1, null, 10)).containsOnly("tag1", "sys1", "sys2");
- assertThat(index.listTags(organization2, null, 10)).containsOnly("tag2", "sys1", "sys2");
- assertThat(index.listTags(organization3, null, 10)).containsOnly("sys1", "sys2");
+ assertThat(underTest.listTags(organization1, null, 10)).containsOnly("tag1", "sys1", "sys2");
+ assertThat(underTest.listTags(organization2, null, 10)).containsOnly("tag2", "sys1", "sys2");
+ assertThat(underTest.listTags(organization3, null, 10)).containsOnly("sys1", "sys2");
}
@Test
- public void available_since() throws InterruptedException {
- RuleKey ruleOld = createRule(setCreatedAt(1000L)).getKey();
- RuleKey ruleOlder = createRule(setCreatedAt(2000L)).getKey();
+ public void available_since() {
+ RuleDefinitionDto ruleOld = createRule(setCreatedAt(1_000L));
+ RuleDefinitionDto ruleOlder = createRule(setCreatedAt(2_000L));
+ index();
// 0. find all rules;
- assertThat(index.search(new RuleQuery(), new SearchOptions()).getIds()).containsOnly(ruleOld, ruleOlder);
+ verifySearch(new RuleQuery(), ruleOld, ruleOlder);
// 1. find all rules available since a date;
RuleQuery availableSinceQuery = new RuleQuery().setAvailableSince(2000L);
- assertThat(index.search(availableSinceQuery, new SearchOptions()).getIds()).containsOnly(ruleOlder);
+ verifySearch(availableSinceQuery, ruleOlder);
// 2. find no new rules since tomorrow.
RuleQuery availableSinceNowQuery = new RuleQuery().setAvailableSince(3000L);
- assertThat(index.search(availableSinceNowQuery, new SearchOptions()).getIds()).containsOnly();
+ verifyEmptySearch(availableSinceNowQuery);
}
@Test
public void global_facet_on_repositories_and_tags() {
- OrganizationDto organization = dbTester.organizations().insert();
+ OrganizationDto organization = db.organizations().insert();
createRule(setRepositoryKey("php"), setSystemTags("sysTag"));
RuleDefinitionDto rule1 = createRule(setRepositoryKey("php"), setSystemTags());
createRuleMetadata(rule1, organization, setTags("tag1"));
RuleDefinitionDto rule2 = createRule(setRepositoryKey("javascript"), setSystemTags());
createRuleMetadata(rule2, organization, setTags("tag1", "tag2"));
+ index();
// should not have any facet!
- RuleQuery query = new RuleQuery().setOrganizationUuid(organization.getUuid());
- SearchIdResult result1 = index.search(query, new SearchOptions());
+ RuleQuery query = new RuleQuery().setOrganization(organization);
+ SearchIdResult result1 = underTest.search(query, new SearchOptions());
assertThat(result1.getFacets().getAll()).isEmpty();
// should not have any facet on non matching query!
- SearchIdResult result2 = index.search(new RuleQuery().setQueryText("aeiou"), new SearchOptions().addFacets(singletonList("repositories")));
+ SearchIdResult result2 = underTest.search(new RuleQuery().setQueryText("aeiou"), new SearchOptions().addFacets(singletonList("repositories")));
assertThat(result2.getFacets().getAll()).hasSize(1);
assertThat(result2.getFacets().getAll().get("repositories")).isEmpty();
// Repositories Facet is preset
- SearchIdResult result3 = index.search(query, new SearchOptions().addFacets(asList("repositories", "tags")));
+ SearchIdResult result3 = underTest.search(query, new SearchOptions().addFacets(asList("repositories", "tags")));
assertThat(result3.getFacets()).isNotNull();
// Verify the value of a given facet
assertThat(result3.getFacets().getAll()).hasSize(2);
}
- private void sticky_facet_rule_setup() {
- insertRuleDefinition(setRepositoryKey("xoo"), setRuleKey("S001"), setLanguage("java"), setSystemTags(), setType(BUG));
- insertRuleDefinition(setRepositoryKey("xoo"), setRuleKey("S002"), setLanguage("java"), setSystemTags(), setType(CODE_SMELL));
- insertRuleDefinition(setRepositoryKey("xoo"), setRuleKey("S003"), setLanguage("java"), setSystemTags("T1", "T2"), setType(CODE_SMELL));
- insertRuleDefinition(setRepositoryKey("xoo"), setRuleKey("S011"), setLanguage("cobol"), setSystemTags(), setType(CODE_SMELL));
- insertRuleDefinition(setRepositoryKey("xoo"), setRuleKey("S012"), setLanguage("cobol"), setSystemTags(), setType(BUG));
- insertRuleDefinition(setRepositoryKey("foo"), setRuleKey("S013"), setLanguage("cobol"), setSystemTags("T3", "T4"), setType(VULNERABILITY));
- insertRuleDefinition(setRepositoryKey("foo"), setRuleKey("S111"), setLanguage("cpp"), setSystemTags(), setType(BUG));
- insertRuleDefinition(setRepositoryKey("foo"), setRuleKey("S112"), setLanguage("cpp"), setSystemTags(), setType(CODE_SMELL));
- insertRuleDefinition(setRepositoryKey("foo"), setRuleKey("S113"), setLanguage("cpp"), setSystemTags("T2", "T3"), setType(CODE_SMELL));
+ private void setupStickyFacets() {
+ createRule(setRepositoryKey("xoo"), setRuleKey("S001"), setLanguage("java"), setSystemTags(), setType(BUG));
+ createRule(setRepositoryKey("xoo"), setRuleKey("S002"), setLanguage("java"), setSystemTags(), setType(CODE_SMELL));
+ createRule(setRepositoryKey("xoo"), setRuleKey("S003"), setLanguage("java"), setSystemTags("T1", "T2"), setType(CODE_SMELL));
+ createRule(setRepositoryKey("xoo"), setRuleKey("S011"), setLanguage("cobol"), setSystemTags(), setType(CODE_SMELL));
+ createRule(setRepositoryKey("xoo"), setRuleKey("S012"), setLanguage("cobol"), setSystemTags(), setType(BUG));
+ createRule(setRepositoryKey("foo"), setRuleKey("S013"), setLanguage("cobol"), setSystemTags("T3", "T4"),
+ setType(VULNERABILITY));
+ createRule(setRepositoryKey("foo"), setRuleKey("S111"), setLanguage("cpp"), setSystemTags(), setType(BUG));
+ createRule(setRepositoryKey("foo"), setRuleKey("S112"), setLanguage("cpp"), setSystemTags(), setType(CODE_SMELL));
+ createRule(setRepositoryKey("foo"), setRuleKey("S113"), setLanguage("cpp"), setSystemTags("T2", "T3"), setType(CODE_SMELL));
+ index();
}
@Test
public void sticky_facets_base() {
- sticky_facet_rule_setup();
+ setupStickyFacets();
RuleQuery query = new RuleQuery();
- assertThat(index.search(query, new SearchOptions()).getIds()).hasSize(9);
+ assertThat(underTest.search(query, new SearchOptions()).getIds()).hasSize(9);
}
/**
- * Facet with no filters at all
- */
+ * Facet with no filters at all
+ */
@Test
public void sticky_facets_no_filters() {
- sticky_facet_rule_setup();
+ setupStickyFacets();
+ OrganizationDto organization = db.organizations().insert();
- RuleQuery query = new RuleQuery()
- .setOrganizationUuid("some_uuid");
+ RuleQuery query = new RuleQuery().setOrganization(organization);
- SearchIdResult result = index.search(query, new SearchOptions().addFacets(asList(FACET_LANGUAGES, FACET_REPOSITORIES,
+ SearchIdResult result = underTest.search(query, new SearchOptions().addFacets(asList(FACET_LANGUAGES, FACET_REPOSITORIES,
FACET_TAGS, FACET_TYPES)));
- assertThat(result.getFacets().getAll()).hasSize(4);
- assertThat(result.getFacets().getAll().get(FACET_LANGUAGES).keySet()).containsOnly("cpp", "java", "cobol");
- assertThat(result.getFacets().getAll().get(FACET_REPOSITORIES).keySet()).containsExactly("xoo", "foo");
- assertThat(result.getFacets().getAll().get(FACET_TAGS).keySet()).containsOnly("T1", "T2", "T3", "T4");
- assertThat(result.getFacets().getAll().get(FACET_TYPES).keySet()).containsOnly("BUG", "CODE_SMELL", "VULNERABILITY");
+ Map<String, LinkedHashMap<String, Long>> facets = result.getFacets().getAll();
+ assertThat(facets).hasSize(4);
+ assertThat(facets.get(FACET_LANGUAGES).keySet()).containsOnly("cpp", "java", "cobol");
+ assertThat(facets.get(FACET_REPOSITORIES).keySet()).containsExactly("xoo", "foo");
+ assertThat(facets.get(FACET_TAGS).keySet()).containsOnly("T1", "T2", "T3", "T4");
+ assertThat(facets.get(FACET_TYPES).keySet()).containsOnly("BUG", "CODE_SMELL", "VULNERABILITY");
}
/**
- * Facet with a language filter
- * -- lang facet should still have all language
- */
+ * Facet with a language filter
+ * -- lang facet should still have all language
+ */
@Test
public void sticky_facets_with_1_filter() {
- sticky_facet_rule_setup();
+ setupStickyFacets();
+ OrganizationDto organization = db.organizations().insert();
- RuleQuery query = new RuleQuery()
- .setOrganizationUuid("some_uuid")
- .setLanguages(ImmutableList.of("cpp"));
+ RuleQuery query = new RuleQuery().setOrganization(organization).setLanguages(ImmutableList.of("cpp"));
- SearchIdResult result = index.search(query, new SearchOptions().addFacets(asList(FACET_LANGUAGES,
+ SearchIdResult result = underTest.search(query, new SearchOptions().addFacets(asList(FACET_LANGUAGES,
FACET_REPOSITORIES, FACET_TAGS)));
assertThat(result.getIds()).hasSize(3);
assertThat(result.getFacets().getAll()).hasSize(3);
@Test
public void tags_facet_should_find_tags_of_specified_organization() {
- OrganizationDto organization = dbTester.organizations().insert();
-
- RuleDefinitionDto rule = insertRuleDefinition(setSystemTags());
- insertRuleMetaData(organization, rule, setTags("bla"));
+ OrganizationDto organization = db.organizations().insert();
+ RuleDefinitionDto rule = createRule(setSystemTags());
+ createRuleMetadata(rule, organization, setTags("bla"));
+ index();
- RuleQuery query = new RuleQuery()
- .setOrganizationUuid(organization.getUuid());
+ RuleQuery query = new RuleQuery().setOrganization(organization);
SearchOptions options = new SearchOptions().addFacets(singletonList(FACET_TAGS));
- SearchIdResult result = index.search(query, options);
+ SearchIdResult result = underTest.search(query, options);
assertThat(result.getFacets().get(FACET_TAGS)).contains(entry("bla", 1L));
}
@Test
public void tags_facet_should_return_top_10_items() {
// default number of items returned in facets = 10
- RuleDefinitionDto rule = insertRuleDefinition(setSystemTags("tag1", "tag2", "tag3", "tag4", "tag5", "tag6", "tag7", "tag8", "tag9", "tagA", "tagB"));
+ RuleDefinitionDto rule = createRule(setSystemTags("tag1", "tag2", "tag3", "tag4", "tag5", "tag6", "tag7", "tag8", "tag9",
+ "tagA", "tagB"));
+ index();
RuleQuery query = new RuleQuery()
- .setOrganizationUuid(dbTester.getDefaultOrganization().getUuid());
+ .setOrganization(db.getDefaultOrganization());
SearchOptions options = new SearchOptions().addFacets(singletonList(FACET_TAGS));
- SearchIdResult result = index.search(query, options);
- assertThat(result.getFacets().get(FACET_TAGS)).containsExactly(entry("tag1", 1L), entry("tag2", 1L), entry("tag3", 1L), entry("tag4", 1L), entry("tag5", 1L),
+ SearchIdResult result = underTest.search(query, options);
+ assertThat(result.getFacets().get(FACET_TAGS)).containsExactly(entry("tag1", 1L), entry("tag2", 1L), entry("tag3", 1L), entry("tag4",
+ 1L), entry("tag5", 1L),
entry("tag6", 1L), entry("tag7", 1L), entry("tag8", 1L), entry("tag9", 1L), entry("tagA", 1L));
}
@Test
public void tags_facet_should_include_matching_selected_items() {
// default number of items returned in facets = 10
- RuleDefinitionDto rule = insertRuleDefinition(setSystemTags("tag1", "tag2", "tag3", "tag4", "tag5", "tag6", "tag7", "tag8", "tag9", "tagA", "tagB"));
+ RuleDefinitionDto rule = createRule(setSystemTags("tag1", "tag2", "tag3", "tag4", "tag5", "tag6", "tag7", "tag8", "tag9",
+ "tagA", "tagB"));
+ index();
RuleQuery query = new RuleQuery()
- .setOrganizationUuid(dbTester.getDefaultOrganization().getUuid())
+ .setOrganization(db.getDefaultOrganization())
.setTags(singletonList("tagB"));
SearchOptions options = new SearchOptions().addFacets(singletonList(FACET_TAGS));
- SearchIdResult result = index.search(query, options);
+ SearchIdResult result = underTest.search(query, options);
assertThat(result.getFacets().get(FACET_TAGS).entrySet()).extracting(e -> entry(e.getKey(), e.getValue())).containsExactly(
// check that selected item is added, although there are 10 other items
entry("tagB", 1L),
- entry("tag1", 1L), entry("tag2", 1L), entry("tag3", 1L), entry("tag4", 1L), entry("tag5", 1L), entry("tag6", 1L), entry("tag7", 1L), entry("tag8", 1L), entry("tag9", 1L),
+ entry("tag1", 1L), entry("tag2", 1L), entry("tag3", 1L), entry("tag4", 1L), entry("tag5", 1L), entry("tag6", 1L), entry("tag7", 1L),
+ entry("tag8", 1L), entry("tag9", 1L),
entry("tagA", 1L));
}
@Test
public void tags_facet_should_not_find_tags_of_any_other_organization() {
- OrganizationDto organization1 = dbTester.organizations().insert();
- OrganizationDto organization2 = dbTester.organizations().insert();
-
- RuleDefinitionDto rule = insertRuleDefinition(setSystemTags());
- insertRuleMetaData(organization1, rule, setTags("bla1"));
- insertRuleMetaData(organization2, rule, setTags("bla2"));
-
- RuleQuery query = new RuleQuery()
- .setOrganizationUuid(organization2.getUuid());
+ OrganizationDto organization1 = db.organizations().insert();
+ OrganizationDto organization2 = db.organizations().insert();
+ RuleDefinitionDto rule = createRule(setSystemTags());
+ createRuleMetadata(rule, organization1, setTags("bla1"));
+ createRuleMetadata(rule, organization2, setTags("bla2"));
+ index();
+
+ RuleQuery query = new RuleQuery().setOrganization(organization2);
SearchOptions options = new SearchOptions().addFacets(singletonList(FACET_TAGS));
- SearchIdResult result = index.search(query, options);
+ SearchIdResult result = underTest.search(query, options);
assertThat(result.getFacets().get(FACET_TAGS).entrySet()).extracting(e -> entry(e.getKey(), e.getValue())).containsExactly(
- entry("bla2", 1L)
- );
- }
-
- @SafeVarargs
- private final void insertRuleMetaData(OrganizationDto organization, RuleDefinitionDto rule, Consumer<RuleMetadataDto>... consumers) {
- dbTester.rules().insertOrUpdateMetadata(rule, organization, consumers);
- ruleIndexer.indexRuleExtension(organization, rule.getKey());
+ entry("bla2", 1L));
}
@Test
public void tags_facet_should_be_available_if_organization_is_specified() {
- RuleQuery query = new RuleQuery()
- .setOrganizationUuid("some_org_id");
+ OrganizationDto organization = db.organizations().insert();
+ RuleQuery query = new RuleQuery().setOrganization(organization);
SearchOptions options = new SearchOptions().addFacets(singletonList(FACET_TAGS));
- SearchIdResult result = index.search(query, options);
+ SearchIdResult result = underTest.search(query, options);
assertThat(result.getFacets().get(FACET_TAGS)).isNotNull();
}
SearchOptions options = new SearchOptions().addFacets(singletonList(FACET_TAGS));
thrown.expectMessage("Cannot use tags facet, if no organization is specified.");
- index.search(query, options);
+ underTest.search(query, options);
}
/**
- * Facet with 2 filters
- * -- lang facet for tag T2
- * -- tag facet for lang cpp
- * -- repository for cpp & T2
- */
+ * Facet with 2 filters
+ * -- lang facet for tag T2
+ * -- tag facet for lang cpp
+ * -- repository for cpp & T2
+ */
@Test
public void sticky_facets_with_2_filters() {
- sticky_facet_rule_setup();
+ setupStickyFacets();
RuleQuery query = new RuleQuery()
- .setOrganizationUuid("some_uuid")
+ .setOrganization(db.getDefaultOrganization())
.setLanguages(ImmutableList.of("cpp"))
.setTags(ImmutableList.of("T2"));
- SearchIdResult result = index.search(query, new SearchOptions().addFacets(asList(FACET_LANGUAGES, FACET_REPOSITORIES, FACET_TAGS)));
+ SearchIdResult result = underTest.search(query, new SearchOptions().addFacets(asList(FACET_LANGUAGES, FACET_REPOSITORIES,
+ FACET_TAGS)));
assertThat(result.getIds()).hasSize(1);
- assertThat(result.getFacets().getAll()).hasSize(3);
- assertThat(result.getFacets().get(FACET_LANGUAGES).keySet()).containsOnly("cpp", "java");
- assertThat(result.getFacets().get(FACET_REPOSITORIES).keySet()).containsOnly("foo");
- assertThat(result.getFacets().get(FACET_TAGS).keySet()).containsOnly("T2", "T3");
+ Facets facets = result.getFacets();
+ assertThat(facets.getAll()).hasSize(3);
+ assertThat(facets.get(FACET_LANGUAGES).keySet()).containsOnly("cpp", "java");
+ assertThat(facets.get(FACET_REPOSITORIES).keySet()).containsOnly("foo");
+ assertThat(facets.get(FACET_TAGS).keySet()).containsOnly("T2", "T3");
}
/**
- * Facet with 3 filters
- * -- lang facet for tag T2
- * -- tag facet for lang cpp & java
- * -- repository for (cpp || java) & T2
- * -- type
- */
+ * Facet with 3 filters
+ * -- lang facet for tag T2
+ * -- tag facet for lang cpp & java
+ * -- repository for (cpp || java) & T2
+ * -- type
+ */
@Test
public void sticky_facets_with_3_filters() {
- sticky_facet_rule_setup();
+ setupStickyFacets();
RuleQuery query = new RuleQuery()
- .setOrganizationUuid("some_uuid")
+ .setOrganization(db.getDefaultOrganization())
.setLanguages(ImmutableList.of("cpp", "java"))
.setTags(ImmutableList.of("T2"))
.setTypes(asList(BUG, CODE_SMELL));
- SearchIdResult result = index.search(query, new SearchOptions().addFacets(asList(FACET_LANGUAGES, FACET_REPOSITORIES, FACET_TAGS,
+ SearchIdResult result = underTest.search(query, new SearchOptions().addFacets(asList(FACET_LANGUAGES, FACET_REPOSITORIES, FACET_TAGS,
FACET_TYPES)));
assertThat(result.getIds()).hasSize(2);
assertThat(result.getFacets().getAll()).hasSize(4);
@Test
public void sort_by_name() {
- RuleDefinitionDto abcd = insertRuleDefinition(setName("abcd"));
- RuleDefinitionDto abc = insertRuleDefinition(setName("ABC"));
- RuleDefinitionDto fgh = insertRuleDefinition(setName("FGH"));
+ RuleDefinitionDto abcd = createRule(setName("abcd"));
+ RuleDefinitionDto abc = createRule(setName("ABC"));
+ RuleDefinitionDto fgh = createRule(setName("FGH"));
+ index();
// ascending
RuleQuery query = new RuleQuery().setSortField(RuleIndexDefinition.FIELD_RULE_NAME);
- SearchIdResult<RuleKey> results = index.search(query, new SearchOptions());
+ SearchIdResult<RuleKey> results = underTest.search(query, new SearchOptions());
assertThat(results.getIds()).containsExactly(abc.getKey(), abcd.getKey(), fgh.getKey());
// descending
query = new RuleQuery().setSortField(RuleIndexDefinition.FIELD_RULE_NAME).setAscendingSort(false);
- results = index.search(query, new SearchOptions());
+ results = underTest.search(query, new SearchOptions());
assertThat(results.getIds()).containsExactly(fgh.getKey(), abcd.getKey(), abc.getKey());
}
@Test
public void default_sort_is_by_updated_at_desc() {
- RuleDefinitionDto old = insertRuleDefinition(setCreatedAt(1000L), setUpdatedAt(1000L));
- RuleDefinitionDto oldest = insertRuleDefinition(setCreatedAt(1000L), setUpdatedAt(3000L));
- RuleDefinitionDto older = insertRuleDefinition(setCreatedAt(1000L), setUpdatedAt(2000L));
+ RuleDefinitionDto old = createRule(setCreatedAt(1000L), setUpdatedAt(1000L));
+ RuleDefinitionDto oldest = createRule(setCreatedAt(1000L), setUpdatedAt(3000L));
+ RuleDefinitionDto older = createRule(setCreatedAt(1000L), setUpdatedAt(2000L));
+ index();
- SearchIdResult<RuleKey> results = index.search(new RuleQuery(), new SearchOptions());
+ SearchIdResult<RuleKey> results = underTest.search(new RuleQuery(), new SearchOptions());
assertThat(results.getIds()).containsExactly(oldest.getKey(), older.getKey(), old.getKey());
}
@Test
public void paging() {
- insertRuleDefinition();
- insertRuleDefinition();
- insertRuleDefinition();
+ createRule();
+ createRule();
+ createRule();
+ index();
// from 0 to 1 included
SearchOptions options = new SearchOptions();
options.setOffset(0).setLimit(2);
- SearchIdResult results = index.search(new RuleQuery(), options);
+ SearchIdResult results = underTest.search(new RuleQuery(), options);
assertThat(results.getTotal()).isEqualTo(3);
assertThat(results.getIds()).hasSize(2);
// from 0 to 9 included
options.setOffset(0).setLimit(10);
- results = index.search(new RuleQuery(), options);
+ results = underTest.search(new RuleQuery(), options);
assertThat(results.getTotal()).isEqualTo(3);
assertThat(results.getIds()).hasSize(3);
// from 2 to 11 included
options.setOffset(2).setLimit(10);
- results = index.search(new RuleQuery(), options);
+ results = underTest.search(new RuleQuery(), options);
assertThat(results.getTotal()).isEqualTo(3);
assertThat(results.getIds()).hasSize(1);
// from 2 to 11 included
options.setOffset(2).setLimit(0);
- results = index.search(new RuleQuery(), options);
+ results = underTest.search(new RuleQuery(), options);
assertThat(results.getTotal()).isEqualTo(3);
assertThat(results.getIds()).hasSize(1);
}
@Test
public void search_all_keys_by_query() {
- insertRuleDefinition(setRepositoryKey("javascript"), setRuleKey("X001"));
- insertRuleDefinition(setRepositoryKey("cobol"), setRuleKey("X001"));
- insertRuleDefinition(setRepositoryKey("php"), setRuleKey("S002"));
+ createRule(setRepositoryKey("javascript"), setRuleKey("X001"));
+ createRule(setRepositoryKey("cobol"), setRuleKey("X001"));
+ createRule(setRepositoryKey("php"), setRuleKey("S002"));
+ index();
// key
- assertThat(index.searchAll(new RuleQuery().setQueryText("X001"))).hasSize(2);
+ assertThat(underTest.searchAll(new RuleQuery().setQueryText("X001"))).hasSize(2);
// partial key does not match
- assertThat(index.searchAll(new RuleQuery().setQueryText("X00"))).isEmpty();
+ assertThat(underTest.searchAll(new RuleQuery().setQueryText("X00"))).isEmpty();
// repo:key -> nice-to-have !
- assertThat(index.searchAll(new RuleQuery().setQueryText("javascript:X001"))).hasSize(1);
+ assertThat(underTest.searchAll(new RuleQuery().setQueryText("javascript:X001"))).hasSize(1);
}
@Test
- public void search_all_keys_by_profile() {
- RuleDefinitionDto rule1 = insertRuleDefinition();
- RuleDefinitionDto rule2 = insertRuleDefinition();
- RuleDefinitionDto rule3 = insertRuleDefinition();
-
- RuleKey rule1Key = rule1.getKey();
- RuleKey rule2Key = rule2.getKey();
- RuleKey rule3Key = rule3.getKey();
-
- indexActiveRules(
- ActiveRuleDocTesting.newDoc(ActiveRuleKey.of(QUALITY_PROFILE_KEY1, rule1Key)),
- ActiveRuleDocTesting.newDoc(ActiveRuleKey.of(QUALITY_PROFILE_KEY2, rule1Key)),
- ActiveRuleDocTesting.newDoc(ActiveRuleKey.of(QUALITY_PROFILE_KEY1, rule2Key)));
-
- assertThat(tester.countDocuments(INDEX_TYPE_ACTIVE_RULE)).isEqualTo(3);
-
- // 1. get all active rules.
- assertThat(index.searchAll(new RuleQuery().setActivation(true)))
- .containsOnly(rule1Key, rule2Key);
-
- // 2. get all inactive rules.
- assertThat(index.searchAll(new RuleQuery().setActivation(false)))
- .containsOnly(rule3Key);
-
- // 3. get all rules not active on profile
- assertThat(index.searchAll(new RuleQuery().setActivation(false).setQProfileKey(QUALITY_PROFILE_KEY2)))
- .containsOnly(rule2Key, rule3Key);
-
- // 4. get all active rules on profile
- assertThat(index.searchAll(new RuleQuery().setActivation(true).setQProfileKey(QUALITY_PROFILE_KEY2)))
- .containsOnly(rule1Key);
- }
-
- @Test
- public void search_all_keys_by_profile_in_specific_organization() {
- RuleDefinitionDto rule1 = insertRuleDefinition();
- RuleDefinitionDto rule2 = insertRuleDefinition();
- RuleDefinitionDto rule3 = insertRuleDefinition();
-
- RuleKey rule1Key = rule1.getKey();
- RuleKey rule2Key = rule2.getKey();
- RuleKey rule3Key = rule3.getKey();
-
- OrganizationDto organization = dbTester.organizations().insert();
-
- indexActiveRules(
- ActiveRuleDocTesting.newDoc(ActiveRuleKey.of(QUALITY_PROFILE_KEY1, rule1Key)).setOrganizationUuid(organization.getUuid()),
- ActiveRuleDocTesting.newDoc(ActiveRuleKey.of(QUALITY_PROFILE_KEY2, rule1Key)).setOrganizationUuid(organization.getUuid()),
- ActiveRuleDocTesting.newDoc(ActiveRuleKey.of(QUALITY_PROFILE_KEY1, rule2Key)).setOrganizationUuid(organization.getUuid()));
-
- assertThat(tester.countDocuments(INDEX_TYPE_ACTIVE_RULE)).isEqualTo(3);
-
- // 1. get all active rules.
- assertThat(index.searchAll(new RuleQuery().setActivation(true).setOrganizationUuid(organization.getUuid())))
- .containsOnly(rule1Key, rule2Key);
-
- // 2. get all inactive rules.
- assertThat(index.searchAll(new RuleQuery().setActivation(false).setOrganizationUuid(organization.getUuid())))
- .containsOnly(rule3Key);
-
- // 3. get all rules not active on profile
- assertThat(index.searchAll(new RuleQuery().setActivation(false).setOrganizationUuid(organization.getUuid()).setQProfileKey(QUALITY_PROFILE_KEY2)))
- .containsOnly(rule2Key, rule3Key);
-
- // 4. get all active rules on profile
- assertThat(index.searchAll(new RuleQuery().setActivation(true).setOrganizationUuid(organization.getUuid()).setQProfileKey(QUALITY_PROFILE_KEY2)))
- .containsOnly(rule1Key);
- }
-
- @SafeVarargs
- private final RuleDefinitionDto insertRuleDefinition(Consumer<RuleDefinitionDto>... populaters) {
- RuleDefinitionDto ruleDefinitionDto = dbTester.rules().insert(populaters);
- ruleIndexer.indexRuleDefinition(ruleDefinitionDto.getKey());
- return ruleDefinitionDto;
- }
+ public void searchAll_keys_by_profile() {
+ RuleDefinitionDto rule1 = createRule();
+ RuleDefinitionDto rule2 = createRule();
+ RuleDefinitionDto rule3 = createRule();
+ QProfileDto profile1 = createJavaProfile();
+ QProfileDto profile2 = createJavaProfile();
+ db.qualityProfiles().activateRule(profile1, rule1);
+ db.qualityProfiles().activateRule(profile2, rule1);
+ db.qualityProfiles().activateRule(profile1, rule2);
+ index();
+
+ // inactive rules on profile
+ assertThat(underTest.searchAll(new RuleQuery().setActivation(false).setQProfile(profile2)))
+ .containsOnly(rule2.getKey(), rule3.getKey());
- private void indexActiveRules(ActiveRuleDoc... docs) {
- activeRuleIndexer.index(asList(docs).iterator());
+ // active rules on profile
+ assertThat(underTest.searchAll(new RuleQuery().setActivation(true).setQProfile(profile2)))
+ .containsOnly(rule1.getKey());
}
}
@Test
public void test_completeShow() {
OrganizationDto organization = dbTester.organizations().insert();
- ActiveRuleCompleter activeRuleCompleter = new ActiveRuleCompleter(dbTester.getDbClient(), new Languages());
+ ActiveRuleCompleter underTest = new ActiveRuleCompleter(dbTester.getDbClient(), new Languages());
RuleDefinitionDto rule = dbTester.rules().insert();
QProfileDto qualityProfile = dbTester.qualityProfiles().insert(organization);
ActiveRuleDto activeRule = dbTester.qualityProfiles().activateRule(qualityProfile, rule);
- List<Rules.Active> result = activeRuleCompleter.completeShow(dbTester.getSession(), organization, rule);
+ List<Rules.Active> result = underTest.completeShow(dbTester.getSession(), organization, rule);
assertThat(result).extracting(Rules.Active::getQProfile).containsExactlyInAnyOrder(qualityProfile.getKee());
assertThat(result).extracting(Rules.Active::getSeverity).containsExactlyInAnyOrder(activeRule.getSeverityString());
import org.sonar.api.server.ws.WebService;
import org.sonar.api.utils.System2;
import org.sonar.db.DbClient;
-import org.sonar.db.DbSession;
import org.sonar.db.DbTester;
import org.sonar.db.organization.OrganizationDto;
import org.sonar.db.qualityprofile.QProfileDto;
@Rule
public ExpectedException thrown = ExpectedException.none();
- DbClient dbClient = dbTester.getDbClient();
+ private DbClient dbClient = dbTester.getDbClient();
- DbSession dbSession = dbTester.getSession();
+ private RuleQueryFactory underTest = new RuleQueryFactory(dbClient, new RuleWsSupport(dbClient, null, TestDefaultOrganizationProvider.from(dbTester)));
- RuleQueryFactory underTest = new RuleQueryFactory(dbClient, new RuleWsSupport(dbClient, null, TestDefaultOrganizationProvider.from(dbTester)));
-
- FakeAction fakeAction = new FakeAction(underTest);
- OrganizationDto organization;
+ private FakeAction fakeAction = new FakeAction(underTest);
+ private OrganizationDto organization;
@Before
public void before() {
assertThat(result.isTemplate()).isNull();
assertThat(result.getLanguages()).isNull();
assertThat(result.getQueryText()).isNull();
- assertThat(result.getQProfileKey()).isNull();
+ assertThat(result.getQProfile()).isNull();
assertThat(result.getRepositories()).isNull();
assertThat(result.getRuleKey()).isNull();
assertThat(result.getSeverities()).isNull();
assertThat(result.isTemplate()).isTrue();
assertThat(result.getLanguages()).containsOnly(qualityProfile.getLanguage());
assertThat(result.getQueryText()).isEqualTo("S001");
- assertThat(result.getQProfileKey()).isEqualTo(qualityProfile.getKee());
- assertThat(result.getOrganizationUuid()).isEqualTo(organization.getUuid());
+ assertThat(result.getQProfile().getKee()).isEqualTo(qualityProfile.getKee());
+ assertThat(result.getOrganization().getUuid()).isEqualTo(organization.getUuid());
assertThat(result.getRepositories()).containsOnly("pmd", "checkstyle");
assertThat(result.getRuleKey()).isNull();
assertThat(result.getSeverities()).containsOnly(MINOR, CRITICAL);
@Test
public void create_query_add_language_from_profile() throws Exception {
- String profileKey = "sonar-way";
- dbClient.qualityProfileDao().insert(dbSession, QProfileDto.createFor(profileKey)
- .setOrganizationUuid(organization.getUuid())
- .setName("Sonar Way")
- .setLanguage("xoo"));
- dbSession.commit();
+ QProfileDto profile = dbTester.qualityProfiles().insert(organization, p -> p.setName("Sonar way").setLanguage("xoo").setKee("sonar-way"));
RuleQuery result = execute(
- PARAM_QPROFILE, profileKey,
+ PARAM_QPROFILE, profile.getKee(),
PARAM_LANGUAGES, "java,js");
- assertThat(result.getQProfileKey()).isEqualTo(profileKey);
+ assertThat(result.getQProfile().getKee()).isEqualTo(profile.getKee());
assertThat(result.getLanguages()).containsOnly("xoo");
}
@Test
public void filter_on_quality_profiles_organization_if_searching_for_actives_with_no_organization_specified() throws Exception {
- String profileKey = "sonar-way";
- dbClient.qualityProfileDao().insert(dbSession, QProfileDto.createFor(profileKey)
- .setOrganizationUuid(organization.getUuid())
- .setName("Sonar Way")
- .setLanguage("xoo"));
- dbSession.commit();
+ QProfileDto profile = dbTester.qualityProfiles().insert(organization, p -> p.setName("Sonar way").setLanguage("xoo").setKee("sonar-way"));
RuleQuery result = execute(
PARAM_ACTIVATION, "true",
- PARAM_QPROFILE, profileKey);
+ PARAM_QPROFILE, profile.getKee());
- assertThat(result.getOrganizationUuid()).isEqualTo(organization.getUuid());
+ assertThat(result.getOrganization().getUuid()).isEqualTo(organization.getUuid());
}
@Test
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("The specified quality profile '" + qualityProfileKey + "' is not part of the specified organization '" + organization2Key + "'");
- RuleQuery result = execute(PARAM_QPROFILE, qualityProfileKey,
+ execute(PARAM_QPROFILE, qualityProfileKey,
PARAM_ORGANIZATION, organization2Key);
}
*/
package org.sonar.server.rule.ws;
-import com.google.common.collect.ImmutableSet;
-import java.util.Date;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.ClassRule;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.sonar.api.rule.RuleKey;
-import org.sonar.api.rule.RuleStatus;
-import org.sonar.api.rule.Severity;
-import org.sonar.api.rules.RuleType;
-import org.sonar.api.server.debt.DebtRemediationFunction;
-import org.sonar.api.server.ws.WebService;
-import org.sonar.api.utils.DateUtils;
-import org.sonar.db.DbClient;
-import org.sonar.db.DbSession;
-import org.sonar.db.organization.OrganizationDto;
-import org.sonar.db.qualityprofile.ActiveRuleDao;
-import org.sonar.db.qualityprofile.ActiveRuleDto;
-import org.sonar.db.qualityprofile.ActiveRuleParamDto;
-import org.sonar.db.qualityprofile.QualityProfileDao;
-import org.sonar.db.qualityprofile.QProfileDto;
-import org.sonar.db.rule.RuleDao;
-import org.sonar.db.rule.RuleDefinitionDto;
-import org.sonar.db.rule.RuleDto;
-import org.sonar.db.rule.RuleParamDto;
-import org.sonar.db.rule.RuleTesting;
-import org.sonar.server.exceptions.NotFoundException;
-import org.sonar.server.organization.DefaultOrganization;
-import org.sonar.server.organization.DefaultOrganizationProvider;
-import org.sonar.server.qualityprofile.QProfileTesting;
-import org.sonar.server.qualityprofile.index.ActiveRuleIndexer;
-import org.sonar.server.rule.index.RuleIndexDefinition;
-import org.sonar.server.rule.index.RuleIndexer;
-import org.sonar.server.tester.ServerTester;
-import org.sonar.server.tester.UserSessionRule;
-import org.sonar.server.ws.WsTester;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.sonarqube.ws.client.rule.RulesWsParameters.PARAM_ACTIVATION;
-import static org.sonarqube.ws.client.rule.RulesWsParameters.PARAM_AVAILABLE_SINCE;
-import static org.sonarqube.ws.client.rule.RulesWsParameters.PARAM_IS_TEMPLATE;
-import static org.sonarqube.ws.client.rule.RulesWsParameters.PARAM_QPROFILE;
-import static org.sonarqube.ws.client.rule.RulesWsParameters.PARAM_RULE_KEY;
-import static org.sonarqube.ws.client.rule.RulesWsParameters.PARAM_STATUSES;
-import static org.sonarqube.ws.client.rule.RulesWsParameters.PARAM_TAGS;
-import static org.sonarqube.ws.client.rule.RulesWsParameters.PARAM_TEMPLATE_KEY;
-
public class SearchActionMediumTest {
- @ClassRule
- public static ServerTester tester = new ServerTester().withEsIndexes().addXoo();
- @Rule
- public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
- @Rule
- public ExpectedException thrown = ExpectedException.none();
-
- private static final String API_ENDPOINT = "api/rules";
- private static final String API_SEARCH_METHOD = "search";
-
- private DbClient db;
- private RuleDao ruleDao;
- private DbSession dbSession;
- private RuleIndexer ruleIndexer;
- private ActiveRuleIndexer activeRuleIndexer;
- private OrganizationDto defaultOrganizationDto;
-
- @Before
- public void setUp() {
- tester.clearDbAndIndexes();
- db = tester.get(DbClient.class);
- ruleDao = tester.get(RuleDao.class);
- dbSession = tester.get(DbClient.class).openSession(false);
- ruleIndexer = tester.get(RuleIndexer.class);
- activeRuleIndexer = tester.get(ActiveRuleIndexer.class);
- DefaultOrganization defaultOrganization = tester.get(DefaultOrganizationProvider.class).get();
- this.defaultOrganizationDto = db.organizationDao().selectByUuid(dbSession, defaultOrganization.getUuid()).get();
- }
-
- @After
- public void after() {
- dbSession.close();
- }
-
- @Test
- public void search_no_rules() throws Exception {
- WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
- request.setParam(WebService.Param.FIELDS, "actives");
- WsTester.Result result = request.execute();
-
- result.assertJson(this.getClass(), "search_no_rules.json");
- }
-
- @Test
- public void filter_by_key_rules() throws Exception {
- insertRule(RuleTesting.newXooX1().getDefinition());
- insertRule(RuleTesting.newXooX2().getDefinition());
- dbSession.commit();
-
- WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
- request.setParam(PARAM_RULE_KEY, RuleTesting.XOO_X1.toString());
- request.setParam(WebService.Param.FIELDS, "actives");
- WsTester.Result result = request.execute();
- result.assertJson("{\"total\":1,\"p\":1,\"ps\":100,\"rules\":[{\"key\":\"xoo:x1\"}]}");
-
- request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
- request.setParam(PARAM_RULE_KEY, RuleKey.of("xoo", "unknown").toString());
- request.setParam(WebService.Param.FIELDS, "actives");
- result = request.execute();
- result.assertJson("{\"total\":0,\"p\":1,\"ps\":100,\"rules\":[],\"actives\":{}}");
- }
-
- @Test
- public void search_2_rules() throws Exception {
- RuleDto rule1 = RuleTesting.newXooX1(defaultOrganizationDto)
- .setType(RuleType.BUG);
- insertRule(rule1.getDefinition());
- ruleDao.insertOrUpdate(dbSession, rule1.getMetadata().setRuleId(rule1.getId()));
- RuleDto rule2 = RuleTesting.newXooX2(defaultOrganizationDto)
- .setType(RuleType.VULNERABILITY);
- insertRule(rule2.getDefinition());
- ruleDao.insertOrUpdate(dbSession, rule2.getMetadata().setRuleId(rule2.getId()));
- dbSession.commit();
-
- WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
- WsTester.Result result = request.execute();
-
- result.assertJson(getClass(), "search_2_rules.json");
- }
-
- @Test
- public void search_2_rules_with_fields_selection() throws Exception {
- insertRule(RuleTesting.newXooX1()
- .setType(RuleType.CODE_SMELL)
- .getDefinition());
- insertRule(RuleTesting.newXooX2()
- .setType(RuleType.BUG)
- .setDescription("A *Xoo* rule")
- .setDescriptionFormat(RuleDto.Format.MARKDOWN)
- .getDefinition());
- dbSession.commit();
-
- WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD).setParam(WebService.Param.FIELDS, "name,htmlDesc,mdDesc");
- WsTester.Result result = request.execute();
-
- result.assertJson(getClass(), "search_2_rules_fields.json");
- }
-
- @Test
- public void return_mandatory_fields_even_when_setting_f_param() throws Exception {
- insertRule(RuleTesting.newXooX1()
- .setName("Rule x1")
- .setType(RuleType.CODE_SMELL)
- .getDefinition());
- dbSession.commit();
-
- WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD).setParam(WebService.Param.FIELDS, "name");
- WsTester.Result result = request.execute();
-
- result.assertJson(getClass(), "return_mandatory_fields_even_when_setting_f_param.json");
- }
-
- @Test
- public void return_lang_field() throws Exception {
- insertRule(RuleTesting.newXooX1().getDefinition());
- dbSession.commit();
-
- WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD).setParam(WebService.Param.FIELDS, "lang");
- WsTester.Result result = request.execute();
-
- result.assertJson("{\"total\":1,\"p\":1,\"ps\":100," +
- "\"rules\":[{\"key\":\"xoo:x1\",\"lang\":\"xoo\"}]}");
- assertThat(result.outputAsString()).doesNotContain("\"langName\"");
- assertThat(result.outputAsString()).doesNotContain("\"name\"");
- }
-
- @Test
- public void return_lang_name_field() throws Exception {
- insertRule(RuleTesting.newXooX1().getDefinition());
- dbSession.commit();
-
- WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD).setParam(WebService.Param.FIELDS, "langName");
- WsTester.Result result = request.execute();
-
- result.assertJson("{\"total\":1,\"p\":1,\"ps\":100," +
- "\"rules\":[{\"key\":\"xoo:x1\",\"langName\":\"Xoo\"}]}");
- assertThat(result.outputAsString()).doesNotContain("\"lang\"");
- assertThat(result.outputAsString()).doesNotContain("\"name\"");
- }
-
- @Test
- public void return_lang_key_field_when_language_name_is_not_available() throws Exception {
- insertRule(RuleTesting.newRule(RuleKey.of("other", "rule")).setLanguage("unknown"));
- dbSession.commit();
-
- WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD).setParam(WebService.Param.FIELDS, "langName");
- WsTester.Result result = request.execute();
-
- result.assertJson("{\"total\":1,\"p\":1,\"ps\":100," +
- "\"rules\":[{\"key\":\"other:rule\",\"langName\":\"unknown\"}]}");
- }
-
- @Test
- public void search_debt_rules_with_default_and_overridden_debt_values() throws Exception {
- RuleDto ruleDto = RuleTesting.newXooX1(defaultOrganizationDto)
- .setDefRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name())
- .setDefRemediationGapMultiplier("1h")
- .setDefRemediationBaseEffort("15min")
- .setRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name())
- .setRemediationGapMultiplier("2h")
- .setRemediationBaseEffort("25min");
- insertRule(ruleDto.getDefinition());
- ruleDao.insertOrUpdate(dbSession, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
- dbSession.commit();
-
- WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
- request.setParam(WebService.Param.FIELDS, "debtRemFn,debtOverloaded,defaultDebtRemFn");
- WsTester.Result result = request.execute();
- result.assertJson(this.getClass(), "search_debt_rules_with_default_and_overridden_debt_values.json");
- }
-
- @Test
- public void search_debt_rules_with_default_linear_offset_and_overridden_constant_debt() throws Exception {
- RuleDto ruleDto = RuleTesting.newXooX1(defaultOrganizationDto)
- .setDefRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name())
- .setDefRemediationGapMultiplier("1h")
- .setDefRemediationBaseEffort("15min")
- .setRemediationFunction(DebtRemediationFunction.Type.CONSTANT_ISSUE.name())
- .setRemediationGapMultiplier(null)
- .setRemediationBaseEffort("5min");
- insertRule(ruleDto.getDefinition());
- ruleDao.insertOrUpdate(dbSession, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
- dbSession.commit();
-
- WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
- request.setParam(WebService.Param.FIELDS, "debtRemFn,debtOverloaded,defaultDebtRemFn");
- WsTester.Result result = request.execute();
- result.assertJson(this.getClass(), "search_debt_rules_with_default_linear_offset_and_overridden_constant_debt.json");
- }
-
- @Test
- public void search_debt_rules_with_default_linear_offset_and_overridden_linear_debt() throws Exception {
- RuleDto ruleDto = RuleTesting.newXooX1(defaultOrganizationDto)
- .setDefRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name())
- .setDefRemediationGapMultiplier("1h")
- .setDefRemediationBaseEffort("15min")
- .setRemediationFunction(DebtRemediationFunction.Type.LINEAR.name())
- .setRemediationGapMultiplier("1h")
- .setRemediationBaseEffort(null);
- insertRule(ruleDto.getDefinition());
- ruleDao.insertOrUpdate(dbSession, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
- dbSession.commit();
-
- WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
- request.setParam(WebService.Param.FIELDS, "debtRemFn,debtOverloaded,defaultDebtRemFn");
- WsTester.Result result = request.execute();
- result.assertJson(this.getClass(), "search_debt_rules_with_default_linear_offset_and_overridden_linear_debt.json");
- }
-
- @Test
- public void search_template_rules() throws Exception {
- RuleDto templateRule = RuleTesting.newXooX1().setIsTemplate(true);
- insertRule(templateRule.getDefinition());
- RuleDto rule = RuleTesting.newXooX2();
- rule.setTemplateId(templateRule.getId());
- insertRule(rule.getDefinition());
- dbSession.commit();
-
- WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
- request.setParam(WebService.Param.FIELDS, "isTemplate");
- request.setParam(PARAM_IS_TEMPLATE, "true");
- WsTester.Result result = request.execute();
- result.assertJson(this.getClass(), "search_template_rules.json");
- }
-
- @Test
- public void search_custom_rules_from_template_key() throws Exception {
- RuleDto templateRule = RuleTesting.newXooX1().setIsTemplate(true);
- insertRule(templateRule.getDefinition());
- insertRule(RuleTesting.newXooX2().setTemplateId(templateRule.getId()).getDefinition());
- dbSession.commit();
-
- WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
- request.setParam(WebService.Param.FIELDS, "templateKey");
- request.setParam(PARAM_TEMPLATE_KEY, "xoo:x1");
- WsTester.Result result = request.execute();
- result.assertJson(this.getClass(), "search_rules_from_template_key.json");
- }
-
- @Test
- public void search_all_active_rules() throws Exception {
- QProfileDto profile = QProfileTesting.newXooP1(defaultOrganizationDto);
- tester.get(QualityProfileDao.class).insert(dbSession, profile);
-
- RuleDefinitionDto rule = RuleTesting.newXooX1().getDefinition();
- insertRule(rule);
-
- ActiveRuleDto activeRule = newActiveRule(profile, rule);
- tester.get(ActiveRuleDao.class).insert(dbSession, activeRule);
-
- dbSession.commit();
-
- activeRuleIndexer.index();
-
- WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
- request.setParam(WebService.Param.TEXT_QUERY, "x1");
- request.setParam(PARAM_ACTIVATION, "true");
- request.setParam(WebService.Param.FIELDS, "");
- request.setParam("organization", defaultOrganizationDto.getKey());
- WsTester.Result result = request.execute();
-
- result.assertJson(this.getClass(), "search_active_rules.json");
- }
-
- @Test
- public void search_profile_active_rules() throws Exception {
- QProfileDto profile = QProfileTesting.newXooP1(defaultOrganizationDto);
- tester.get(QualityProfileDao.class).insert(dbSession, profile);
-
- QProfileDto profile2 = QProfileTesting.newXooP2(defaultOrganizationDto);
- tester.get(QualityProfileDao.class).insert(dbSession, profile2);
-
- dbSession.commit();
-
- RuleDefinitionDto rule = RuleTesting.newXooX1().getDefinition();
- insertRule(rule);
-
- RuleParamDto param = RuleParamDto.createFor(rule)
- .setDefaultValue("some value")
- .setType("string")
- .setDescription("My small description")
- .setName("my_var");
- ruleDao.insertRuleParam(dbSession, rule, param);
-
- RuleParamDto param2 = RuleParamDto.createFor(rule)
- .setDefaultValue("other value")
- .setType("integer")
- .setDescription("My small description")
- .setName("the_var");
- ruleDao.insertRuleParam(dbSession, rule, param2);
-
- // SONAR-7083
- RuleParamDto param3 = RuleParamDto.createFor(rule)
- .setDefaultValue(null)
- .setType("string")
- .setDescription("Empty Param")
- .setName("empty_var");
- ruleDao.insertRuleParam(dbSession, rule, param3);
-
- ActiveRuleDto activeRule = newActiveRule(profile, rule);
- tester.get(ActiveRuleDao.class).insert(dbSession, activeRule);
- ActiveRuleDto activeRule2 = newActiveRule(profile2, rule);
- tester.get(ActiveRuleDao.class).insert(dbSession, activeRule2);
-
- ActiveRuleParamDto activeRuleParam = ActiveRuleParamDto.createFor(param)
- .setValue("The VALUE");
- tester.get(ActiveRuleDao.class).insertParam(dbSession, activeRule2, activeRuleParam);
-
- ActiveRuleParamDto activeRuleParam2 = ActiveRuleParamDto.createFor(param2)
- .setValue("The Other Value");
- tester.get(ActiveRuleDao.class).insertParam(dbSession, activeRule2, activeRuleParam2);
-
- ActiveRuleParamDto activeRuleParam3 = ActiveRuleParamDto.createFor(param3)
- .setValue(null);
- tester.get(ActiveRuleDao.class).insertParam(dbSession, activeRule2, activeRuleParam3);
-
- dbSession.commit();
-
- activeRuleIndexer.index();
-
- WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
- request.setParam(WebService.Param.TEXT_QUERY, "x1");
- request.setParam(PARAM_ACTIVATION, "true");
- request.setParam(PARAM_QPROFILE, profile2.getKee());
- request.setParam(WebService.Param.FIELDS, "actives");
- WsTester.Result result = request.execute();
- result.assertJson(this.getClass(), "search_profile_active_rules.json");
-
- WsTester.TestRequest request2 = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD)
- .setParam(PARAM_ACTIVATION, "true")
- .setParam(PARAM_QPROFILE, "unknown_profile")
- .setParam(WebService.Param.FIELDS, "actives");
-
- thrown.expect(NotFoundException.class);
- thrown.expectMessage("The specified qualityProfile 'unknown_profile' does not exist");
-
- request2.execute();
- }
-
- @Test
- public void search_profile_active_rules_with_inheritance() throws Exception {
- QProfileDto profile = QProfileTesting.newXooP1(defaultOrganizationDto);
- tester.get(QualityProfileDao.class).insert(dbSession, profile);
-
- QProfileDto profile2 = QProfileTesting.newXooP2(defaultOrganizationDto).setParentKee(profile.getKee());
- tester.get(QualityProfileDao.class).insert(dbSession, profile2);
-
- dbSession.commit();
-
- RuleDefinitionDto rule = RuleTesting.newXooX1().getDefinition();
- insertRule(rule);
-
- ActiveRuleDto activeRule = newActiveRule(profile, rule);
- tester.get(ActiveRuleDao.class).insert(dbSession, activeRule);
- ActiveRuleDto activeRule2 = newActiveRule(profile2, rule).setInheritance(ActiveRuleDto.OVERRIDES).setSeverity(Severity.CRITICAL);
- tester.get(ActiveRuleDao.class).insert(dbSession, activeRule2);
-
- dbSession.commit();
-
- activeRuleIndexer.index();
-
- WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
- request.setParam(WebService.Param.TEXT_QUERY, "x1");
- request.setParam(PARAM_ACTIVATION, "true");
- request.setParam(PARAM_QPROFILE, profile2.getKee());
- request.setParam(WebService.Param.FIELDS, "actives");
- WsTester.Result result = request.execute();
- result.assertJson(this.getClass(), "search_profile_active_rules_inheritance.json");
- }
-
- @Test
- public void search_all_active_rules_params() throws Exception {
- QProfileDto profile = QProfileTesting.newXooP1(defaultOrganizationDto);
- tester.get(QualityProfileDao.class).insert(dbSession, profile);
- RuleDefinitionDto rule = RuleTesting.newXooX1().getDefinition();
- insertRule(rule);
- dbSession.commit();
-
- RuleParamDto param = RuleParamDto.createFor(rule)
- .setDefaultValue("some value")
- .setType("string")
- .setDescription("My small description")
- .setName("my_var");
- ruleDao.insertRuleParam(dbSession, rule, param);
-
- RuleParamDto param2 = RuleParamDto.createFor(rule)
- .setDefaultValue("other value")
- .setType("integer")
- .setDescription("My small description")
- .setName("the_var");
- ruleDao.insertRuleParam(dbSession, rule, param2);
-
- ActiveRuleDto activeRule = newActiveRule(profile, rule);
- tester.get(ActiveRuleDao.class).insert(dbSession, activeRule);
-
- ActiveRuleParamDto activeRuleParam = ActiveRuleParamDto.createFor(param)
- .setValue("The VALUE");
- tester.get(ActiveRuleDao.class).insertParam(dbSession, activeRule, activeRuleParam);
-
- ActiveRuleParamDto activeRuleParam2 = ActiveRuleParamDto.createFor(param2)
- .setValue("The Other Value");
- tester.get(ActiveRuleDao.class).insertParam(dbSession, activeRule, activeRuleParam2);
-
- dbSession.commit();
-
- activeRuleIndexer.index();
-
- WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
- request.setParam(WebService.Param.TEXT_QUERY, "x1");
- request.setParam(PARAM_ACTIVATION, "true");
- request.setParam(WebService.Param.FIELDS, "params");
- WsTester.Result result = request.execute();
-
- result.assertJson(this.getClass(), "search_active_rules_params.json");
- }
-
- @Test
- public void get_note_as_markdown_and_html() throws Exception {
- QProfileDto profile = QProfileTesting.newXooP1("org-123");
- tester.get(QualityProfileDao.class).insert(dbSession, profile);
- RuleDto rule = RuleTesting.newXooX1(defaultOrganizationDto).setNoteData("this is *bold*");
- insertRule(rule.getDefinition());
- ruleDao.insertOrUpdate(dbSession, rule.getMetadata().setRuleId(rule.getId()));
-
- dbSession.commit();
-
- activeRuleIndexer.index();
-
- WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
- request.setParam(WebService.Param.FIELDS, "htmlNote, mdNote");
- WsTester.Result result = request.execute();
- result.assertJson(this.getClass(), "get_note_as_markdown_and_html.json");
- }
-
- @Test
- public void filter_by_tags() throws Exception {
- insertRule(RuleTesting.newRule()
- .setRepositoryKey("xoo").setRuleKey("x1")
- .setSystemTags(ImmutableSet.of("tag1")));
- insertRule(RuleTesting.newRule()
- .setSystemTags(ImmutableSet.of("tag2")));
-
- activeRuleIndexer.index();
-
- WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
- request.setParam(PARAM_TAGS, "tag1");
- request.setParam(WebService.Param.FIELDS, "sysTags, tags");
- request.setParam(WebService.Param.FACETS, "tags");
- WsTester.Result result = request.execute();
- result.assertJson(this.getClass(), "filter_by_tags.json");
- }
-
- @Test
- public void severities_facet_should_have_all_severities() throws Exception {
- WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
- request.setParam(WebService.Param.FACETS, "severities");
- request.execute().assertJson(this.getClass(), "severities_facet.json");
- }
-
- @Test
- public void statuses_facet_should_have_all_statuses_except_removed() throws Exception {
- WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
- request.setParam(WebService.Param.FACETS, "statuses");
- request.execute().assertJson(this.getClass(), "statuses_facet.json");
- }
-
- @Test
- public void statuses_facet_should_be_sticky() throws Exception {
- RuleDefinitionDto definition = RuleTesting.newXooX1().getDefinition();
- insertRule(definition);
- insertRule(RuleTesting.newXooX2().setStatus(RuleStatus.BETA).getDefinition());
- insertRule(RuleTesting.newXooX3().setStatus(RuleStatus.DEPRECATED).getDefinition());
-
- dbSession.commit();
-
- WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
- request.setParam(PARAM_STATUSES, "DEPRECATED");
- request.setParam(WebService.Param.FACETS, "statuses");
- request.execute().assertJson(this.getClass(), "statuses_facet_sticky.json");
- }
-
- @Test
- public void sort_by_name() throws Exception {
- insertRule(RuleTesting.newXooX1()
- .setName("Dodgy - Consider returning a zero length array rather than null ")
- .getDefinition());
- insertRule(RuleTesting.newXooX2()
- .setName("Bad practice - Creates an empty zip file entry")
- .getDefinition());
- insertRule(RuleTesting.newXooX3()
- .setName("XPath rule")
- .getDefinition());
-
- dbSession.commit();
-
- // 1. Sort Name Asc
- WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
- request.setParam(WebService.Param.FIELDS, "");
- request.setParam(WebService.Param.SORT, "name");
- request.setParam(WebService.Param.ASCENDING, "true");
-
- WsTester.Result result = request.execute();
- result.assertJson("{\"total\":3,\"p\":1,\"ps\":100,\"rules\":[{\"key\":\"xoo:x2\"},{\"key\":\"xoo:x1\"},{\"key\":\"xoo:x3\"}]}");
-
- // 2. Sort Name DESC
- request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
- request.setParam(WebService.Param.FIELDS, "");
- request.setParam(WebService.Param.SORT, RuleIndexDefinition.FIELD_RULE_NAME);
- request.setParam(WebService.Param.ASCENDING, "false");
-
- result = request.execute();
- result.assertJson("{\"total\":3,\"p\":1,\"ps\":100,\"rules\":[{\"key\":\"xoo:x3\"},{\"key\":\"xoo:x1\"},{\"key\":\"xoo:x2\"}]}");
- }
-
- @Test
- public void available_since() throws Exception {
- Date since = new Date();
- insertRule(RuleTesting.newXooX1()
- .setUpdatedAt(since.getTime())
- .setCreatedAt(since.getTime())
- .getDefinition());
- insertRule(RuleTesting.newXooX2()
- .setUpdatedAt(since.getTime())
- .setCreatedAt(since.getTime())
- .getDefinition());
-
- dbSession.commit();
- dbSession.clearCache();
-
- // 1. find today's rules
- WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
- request.setParam(WebService.Param.FIELDS, "");
- request.setParam(PARAM_AVAILABLE_SINCE, DateUtils.formatDate(since));
- request.setParam(WebService.Param.SORT, RuleIndexDefinition.FIELD_RULE_KEY);
- WsTester.Result result = request.execute();
- result.assertJson("{\"total\":2,\"p\":1,\"ps\":100,\"rules\":[{\"key\":\"xoo:x1\"},{\"key\":\"xoo:x2\"}]}");
-
- // 2. no rules since tomorrow
- request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
- request.setParam(WebService.Param.FIELDS, "");
- request.setParam(PARAM_AVAILABLE_SINCE, DateUtils.formatDate(DateUtils.addDays(since, 1)));
- result = request.execute();
- result.assertJson("{\"total\":0,\"p\":1,\"ps\":100,\"rules\":[]}");
- }
-
- @Test
- public void search_rules_with_deprecated_fields() throws Exception {
- RuleDto ruleDto = RuleTesting.newXooX1(defaultOrganizationDto)
- .setDefRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name())
- .setDefRemediationGapMultiplier("1h")
- .setDefRemediationBaseEffort("15min")
- .setRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name())
- .setRemediationGapMultiplier("2h")
- .setRemediationBaseEffort("25min");
- insertRule(ruleDto.getDefinition());
- ruleDao.insertOrUpdate(dbSession, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
- dbSession.commit();
-
- WsTester.TestRequest request = tester.wsTester()
- .newGetRequest(API_ENDPOINT, API_SEARCH_METHOD)
- .setParam(WebService.Param.FIELDS, "name,defaultDebtRemFn,debtRemFn,effortToFixDescription,debtOverloaded");
- WsTester.Result result = request.execute();
-
- result.assertJson(getClass(), "search_rules_with_deprecated_fields.json");
- }
-
- private ActiveRuleDto newActiveRule(QProfileDto profile, RuleDefinitionDto rule) {
- return ActiveRuleDto.createFor(profile, rule)
- .setInheritance(null)
- .setSeverity("BLOCKER");
- }
-
- private void insertRule(RuleDefinitionDto definition) {
- ruleDao.insert(dbSession, definition);
- dbSession.commit();
- ruleIndexer.indexRuleDefinition(definition.getKey());
- }
+// @ClassRule
+// public static ServerTester tester = new ServerTester().withEsIndexes().addXoo();
+// @Rule
+// public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
+// @Rule
+// public ExpectedException thrown = ExpectedException.none();
+//
+// private static final String API_ENDPOINT = "api/rules";
+// private static final String API_SEARCH_METHOD = "search";
+//
+// private DbClient db;
+// private RuleDao ruleDao;
+// private DbSession dbSession;
+// private RuleIndexer ruleIndexer;
+// private ActiveRuleIndexer activeRuleIndexer;
+// private OrganizationDto defaultOrganizationDto;
+//
+// @Before
+// public void setUp() {
+// tester.clearDbAndIndexes();
+// db = tester.get(DbClient.class);
+// ruleDao = tester.get(RuleDao.class);
+// dbSession = tester.get(DbClient.class).openSession(false);
+// ruleIndexer = tester.get(RuleIndexer.class);
+// activeRuleIndexer = tester.get(ActiveRuleIndexer.class);
+// DefaultOrganization defaultOrganization = tester.get(DefaultOrganizationProvider.class).get();
+// this.defaultOrganizationDto = db.organizationDao().selectByUuid(dbSession, defaultOrganization.getUuid()).get();
+// }
+//
+// @After
+// public void after() {
+// dbSession.close();
+// }
+//
+// @Test
+// public void search_no_rules() throws Exception {
+// WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
+// request.setParam(WebService.Param.FIELDS, "actives");
+// WsTester.Result result = request.execute();
+//
+// result.assertJson(this.getClass(), "search_no_rules.json");
+// }
+//
+// @Test
+// public void filter_by_key_rules() throws Exception {
+// insertRule(RuleTesting.newXooX1().getDefinition());
+// insertRule(RuleTesting.newXooX2().getDefinition());
+// dbSession.commit();
+//
+// WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
+// request.setParam(PARAM_RULE_KEY, RuleTesting.XOO_X1.toString());
+// request.setParam(WebService.Param.FIELDS, "actives");
+// WsTester.Result result = request.execute();
+// result.assertJson("{\"total\":1,\"p\":1,\"ps\":100,\"rules\":[{\"key\":\"xoo:x1\"}]}");
+//
+// request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
+// request.setParam(PARAM_RULE_KEY, RuleKey.of("xoo", "unknown").toString());
+// request.setParam(WebService.Param.FIELDS, "actives");
+// result = request.execute();
+// result.assertJson("{\"total\":0,\"p\":1,\"ps\":100,\"rules\":[],\"actives\":{}}");
+// }
+//
+// @Test
+// public void search_2_rules() throws Exception {
+// RuleDto rule1 = RuleTesting.newXooX1(defaultOrganizationDto)
+// .setType(RuleType.BUG);
+// insertRule(rule1.getDefinition());
+// ruleDao.insertOrUpdate(dbSession, rule1.getMetadata().setRuleId(rule1.getId()));
+// RuleDto rule2 = RuleTesting.newXooX2(defaultOrganizationDto)
+// .setType(RuleType.VULNERABILITY);
+// insertRule(rule2.getDefinition());
+// ruleDao.insertOrUpdate(dbSession, rule2.getMetadata().setRuleId(rule2.getId()));
+// dbSession.commit();
+//
+// WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
+// WsTester.Result result = request.execute();
+//
+// result.assertJson(getClass(), "search_2_rules.json");
+// }
+//
+// @Test
+// public void search_2_rules_with_fields_selection() throws Exception {
+// insertRule(RuleTesting.newXooX1()
+// .setType(RuleType.CODE_SMELL)
+// .getDefinition());
+// insertRule(RuleTesting.newXooX2()
+// .setType(RuleType.BUG)
+// .setDescription("A *Xoo* rule")
+// .setDescriptionFormat(RuleDto.Format.MARKDOWN)
+// .getDefinition());
+// dbSession.commit();
+//
+// WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD).setParam(WebService.Param.FIELDS, "name,htmlDesc,mdDesc");
+// WsTester.Result result = request.execute();
+//
+// result.assertJson(getClass(), "search_2_rules_fields.json");
+// }
+//
+// @Test
+// public void return_mandatory_fields_even_when_setting_f_param() throws Exception {
+// insertRule(RuleTesting.newXooX1()
+// .setName("Rule x1")
+// .setType(RuleType.CODE_SMELL)
+// .getDefinition());
+// dbSession.commit();
+//
+// WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD).setParam(WebService.Param.FIELDS, "name");
+// WsTester.Result result = request.execute();
+//
+// result.assertJson(getClass(), "return_mandatory_fields_even_when_setting_f_param.json");
+// }
+//
+// @Test
+// public void return_lang_field() throws Exception {
+// insertRule(RuleTesting.newXooX1().getDefinition());
+// dbSession.commit();
+//
+// WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD).setParam(WebService.Param.FIELDS, "lang");
+// WsTester.Result result = request.execute();
+//
+// result.assertJson("{\"total\":1,\"p\":1,\"ps\":100," +
+// "\"rules\":[{\"key\":\"xoo:x1\",\"lang\":\"xoo\"}]}");
+// assertThat(result.outputAsString()).doesNotContain("\"langName\"");
+// assertThat(result.outputAsString()).doesNotContain("\"name\"");
+// }
+//
+// @Test
+// public void return_lang_name_field() throws Exception {
+// insertRule(RuleTesting.newXooX1().getDefinition());
+// dbSession.commit();
+//
+// WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD).setParam(WebService.Param.FIELDS, "langName");
+// WsTester.Result result = request.execute();
+//
+// result.assertJson("{\"total\":1,\"p\":1,\"ps\":100," +
+// "\"rules\":[{\"key\":\"xoo:x1\",\"langName\":\"Xoo\"}]}");
+// assertThat(result.outputAsString()).doesNotContain("\"lang\"");
+// assertThat(result.outputAsString()).doesNotContain("\"name\"");
+// }
+//
+// @Test
+// public void return_lang_key_field_when_language_name_is_not_available() throws Exception {
+// insertRule(RuleTesting.newRule(RuleKey.of("other", "rule")).setLanguage("unknown"));
+// dbSession.commit();
+//
+// WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD).setParam(WebService.Param.FIELDS, "langName");
+// WsTester.Result result = request.execute();
+//
+// result.assertJson("{\"total\":1,\"p\":1,\"ps\":100," +
+// "\"rules\":[{\"key\":\"other:rule\",\"langName\":\"unknown\"}]}");
+// }
+//
+// @Test
+// public void search_debt_rules_with_default_and_overridden_debt_values() throws Exception {
+// RuleDto ruleDto = RuleTesting.newXooX1(defaultOrganizationDto)
+// .setDefRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name())
+// .setDefRemediationGapMultiplier("1h")
+// .setDefRemediationBaseEffort("15min")
+// .setRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name())
+// .setRemediationGapMultiplier("2h")
+// .setRemediationBaseEffort("25min");
+// insertRule(ruleDto.getDefinition());
+// ruleDao.insertOrUpdate(dbSession, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
+// dbSession.commit();
+//
+// WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
+// request.setParam(WebService.Param.FIELDS, "debtRemFn,debtOverloaded,defaultDebtRemFn");
+// WsTester.Result result = request.execute();
+// result.assertJson(this.getClass(), "search_debt_rules_with_default_and_overridden_debt_values.json");
+// }
+//
+// @Test
+// public void search_debt_rules_with_default_linear_offset_and_overridden_constant_debt() throws Exception {
+// RuleDto ruleDto = RuleTesting.newXooX1(defaultOrganizationDto)
+// .setDefRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name())
+// .setDefRemediationGapMultiplier("1h")
+// .setDefRemediationBaseEffort("15min")
+// .setRemediationFunction(DebtRemediationFunction.Type.CONSTANT_ISSUE.name())
+// .setRemediationGapMultiplier(null)
+// .setRemediationBaseEffort("5min");
+// insertRule(ruleDto.getDefinition());
+// ruleDao.insertOrUpdate(dbSession, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
+// dbSession.commit();
+//
+// WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
+// request.setParam(WebService.Param.FIELDS, "debtRemFn,debtOverloaded,defaultDebtRemFn");
+// WsTester.Result result = request.execute();
+// result.assertJson(this.getClass(), "search_debt_rules_with_default_linear_offset_and_overridden_constant_debt.json");
+// }
+//
+// @Test
+// public void search_debt_rules_with_default_linear_offset_and_overridden_linear_debt() throws Exception {
+// RuleDto ruleDto = RuleTesting.newXooX1(defaultOrganizationDto)
+// .setDefRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name())
+// .setDefRemediationGapMultiplier("1h")
+// .setDefRemediationBaseEffort("15min")
+// .setRemediationFunction(DebtRemediationFunction.Type.LINEAR.name())
+// .setRemediationGapMultiplier("1h")
+// .setRemediationBaseEffort(null);
+// insertRule(ruleDto.getDefinition());
+// ruleDao.insertOrUpdate(dbSession, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
+// dbSession.commit();
+//
+// WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
+// request.setParam(WebService.Param.FIELDS, "debtRemFn,debtOverloaded,defaultDebtRemFn");
+// WsTester.Result result = request.execute();
+// result.assertJson(this.getClass(), "search_debt_rules_with_default_linear_offset_and_overridden_linear_debt.json");
+// }
+//
+// @Test
+// public void search_template_rules() throws Exception {
+// RuleDto templateRule = RuleTesting.newXooX1().setIsTemplate(true);
+// insertRule(templateRule.getDefinition());
+// RuleDto rule = RuleTesting.newXooX2();
+// rule.setTemplateId(templateRule.getId());
+// insertRule(rule.getDefinition());
+// dbSession.commit();
+//
+// WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
+// request.setParam(WebService.Param.FIELDS, "isTemplate");
+// request.setParam(PARAM_IS_TEMPLATE, "true");
+// WsTester.Result result = request.execute();
+// result.assertJson(this.getClass(), "search_template_rules.json");
+// }
+//
+// @Test
+// public void search_custom_rules_from_template_key() throws Exception {
+// RuleDto templateRule = RuleTesting.newXooX1().setIsTemplate(true);
+// insertRule(templateRule.getDefinition());
+// insertRule(RuleTesting.newXooX2().setTemplateId(templateRule.getId()).getDefinition());
+// dbSession.commit();
+//
+// WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
+// request.setParam(WebService.Param.FIELDS, "templateKey");
+// request.setParam(PARAM_TEMPLATE_KEY, "xoo:x1");
+// WsTester.Result result = request.execute();
+// result.assertJson(this.getClass(), "search_rules_from_template_key.json");
+// }
+//
+// @Test
+// public void search_all_active_rules() throws Exception {
+// QProfileDto profile = QProfileTesting.newXooP1(defaultOrganizationDto);
+// tester.get(QualityProfileDao.class).insert(dbSession, profile);
+//
+// RuleDefinitionDto rule = RuleTesting.newXooX1().getDefinition();
+// insertRule(rule);
+//
+// ActiveRuleDto activeRule = newActiveRule(profile, rule);
+// tester.get(ActiveRuleDao.class).insert(dbSession, activeRule);
+//
+// dbSession.commit();
+//
+// activeRuleIndexer.index();
+//
+// WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
+// request.setParam(WebService.Param.TEXT_QUERY, "x1");
+// request.setParam(PARAM_ACTIVATION, "true");
+// request.setParam(WebService.Param.FIELDS, "");
+// request.setParam("organization", defaultOrganizationDto.getKey());
+// WsTester.Result result = request.execute();
+//
+// result.assertJson(this.getClass(), "search_active_rules.json");
+// }
+//
+// @Test
+// public void search_profile_active_rules() throws Exception {
+// QProfileDto profile = QProfileTesting.newXooP1(defaultOrganizationDto);
+// tester.get(QualityProfileDao.class).insert(dbSession, profile);
+//
+// QProfileDto profile2 = QProfileTesting.newXooP2(defaultOrganizationDto);
+// tester.get(QualityProfileDao.class).insert(dbSession, profile2);
+//
+// dbSession.commit();
+//
+// RuleDefinitionDto rule = RuleTesting.newXooX1().getDefinition();
+// insertRule(rule);
+//
+// RuleParamDto param = RuleParamDto.createFor(rule)
+// .setDefaultValue("some value")
+// .setType("string")
+// .setDescription("My small description")
+// .setName("my_var");
+// ruleDao.insertRuleParam(dbSession, rule, param);
+//
+// RuleParamDto param2 = RuleParamDto.createFor(rule)
+// .setDefaultValue("other value")
+// .setType("integer")
+// .setDescription("My small description")
+// .setName("the_var");
+// ruleDao.insertRuleParam(dbSession, rule, param2);
+//
+// // SONAR-7083
+// RuleParamDto param3 = RuleParamDto.createFor(rule)
+// .setDefaultValue(null)
+// .setType("string")
+// .setDescription("Empty Param")
+// .setName("empty_var");
+// ruleDao.insertRuleParam(dbSession, rule, param3);
+//
+// ActiveRuleDto activeRule = newActiveRule(profile, rule);
+// tester.get(ActiveRuleDao.class).insert(dbSession, activeRule);
+// ActiveRuleDto activeRule2 = newActiveRule(profile2, rule);
+// tester.get(ActiveRuleDao.class).insert(dbSession, activeRule2);
+//
+// ActiveRuleParamDto activeRuleParam = ActiveRuleParamDto.createFor(param)
+// .setValue("The VALUE");
+// tester.get(ActiveRuleDao.class).insertParam(dbSession, activeRule2, activeRuleParam);
+//
+// ActiveRuleParamDto activeRuleParam2 = ActiveRuleParamDto.createFor(param2)
+// .setValue("The Other Value");
+// tester.get(ActiveRuleDao.class).insertParam(dbSession, activeRule2, activeRuleParam2);
+//
+// ActiveRuleParamDto activeRuleParam3 = ActiveRuleParamDto.createFor(param3)
+// .setValue(null);
+// tester.get(ActiveRuleDao.class).insertParam(dbSession, activeRule2, activeRuleParam3);
+//
+// dbSession.commit();
+//
+// activeRuleIndexer.index();
+//
+// WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
+// request.setParam(WebService.Param.TEXT_QUERY, "x1");
+// request.setParam(PARAM_ACTIVATION, "true");
+// request.setParam(PARAM_QPROFILE, profile2.getKee());
+// request.setParam(WebService.Param.FIELDS, "actives");
+// WsTester.Result result = request.execute();
+// result.assertJson(this.getClass(), "search_profile_active_rules.json");
+//
+// WsTester.TestRequest request2 = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD)
+// .setParam(PARAM_ACTIVATION, "true")
+// .setParam(PARAM_QPROFILE, "unknown_profile")
+// .setParam(WebService.Param.FIELDS, "actives");
+//
+// thrown.expect(NotFoundException.class);
+// thrown.expectMessage("The specified qualityProfile 'unknown_profile' does not exist");
+//
+// request2.execute();
+// }
+//
+// @Test
+// public void search_profile_active_rules_with_inheritance() throws Exception {
+// QProfileDto profile = QProfileTesting.newXooP1(defaultOrganizationDto);
+// tester.get(QualityProfileDao.class).insert(dbSession, profile);
+//
+// QProfileDto profile2 = QProfileTesting.newXooP2(defaultOrganizationDto).setParentKee(profile.getKee());
+// tester.get(QualityProfileDao.class).insert(dbSession, profile2);
+//
+// dbSession.commit();
+//
+// RuleDefinitionDto rule = RuleTesting.newXooX1().getDefinition();
+// insertRule(rule);
+//
+// ActiveRuleDto activeRule = newActiveRule(profile, rule);
+// tester.get(ActiveRuleDao.class).insert(dbSession, activeRule);
+// ActiveRuleDto activeRule2 = newActiveRule(profile2, rule).setInheritance(ActiveRuleDto.OVERRIDES).setSeverity(Severity.CRITICAL);
+// tester.get(ActiveRuleDao.class).insert(dbSession, activeRule2);
+//
+// dbSession.commit();
+//
+// activeRuleIndexer.index();
+//
+// WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
+// request.setParam(WebService.Param.TEXT_QUERY, "x1");
+// request.setParam(PARAM_ACTIVATION, "true");
+// request.setParam(PARAM_QPROFILE, profile2.getKee());
+// request.setParam(WebService.Param.FIELDS, "actives");
+// WsTester.Result result = request.execute();
+// result.assertJson(this.getClass(), "search_profile_active_rules_inheritance.json");
+// }
+//
+// @Test
+// public void search_all_active_rules_params() throws Exception {
+// QProfileDto profile = QProfileTesting.newXooP1(defaultOrganizationDto);
+// tester.get(QualityProfileDao.class).insert(dbSession, profile);
+// RuleDefinitionDto rule = RuleTesting.newXooX1().getDefinition();
+// insertRule(rule);
+// dbSession.commit();
+//
+// RuleParamDto param = RuleParamDto.createFor(rule)
+// .setDefaultValue("some value")
+// .setType("string")
+// .setDescription("My small description")
+// .setName("my_var");
+// ruleDao.insertRuleParam(dbSession, rule, param);
+//
+// RuleParamDto param2 = RuleParamDto.createFor(rule)
+// .setDefaultValue("other value")
+// .setType("integer")
+// .setDescription("My small description")
+// .setName("the_var");
+// ruleDao.insertRuleParam(dbSession, rule, param2);
+//
+// ActiveRuleDto activeRule = newActiveRule(profile, rule);
+// tester.get(ActiveRuleDao.class).insert(dbSession, activeRule);
+//
+// ActiveRuleParamDto activeRuleParam = ActiveRuleParamDto.createFor(param)
+// .setValue("The VALUE");
+// tester.get(ActiveRuleDao.class).insertParam(dbSession, activeRule, activeRuleParam);
+//
+// ActiveRuleParamDto activeRuleParam2 = ActiveRuleParamDto.createFor(param2)
+// .setValue("The Other Value");
+// tester.get(ActiveRuleDao.class).insertParam(dbSession, activeRule, activeRuleParam2);
+//
+// dbSession.commit();
+//
+// activeRuleIndexer.index();
+//
+// WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
+// request.setParam(WebService.Param.TEXT_QUERY, "x1");
+// request.setParam(PARAM_ACTIVATION, "true");
+// request.setParam(WebService.Param.FIELDS, "params");
+// WsTester.Result result = request.execute();
+//
+// result.assertJson(this.getClass(), "search_active_rules_params.json");
+// }
+//
+// @Test
+// public void get_note_as_markdown_and_html() throws Exception {
+// QProfileDto profile = QProfileTesting.newXooP1("org-123");
+// tester.get(QualityProfileDao.class).insert(dbSession, profile);
+// RuleDto rule = RuleTesting.newXooX1(defaultOrganizationDto).setNoteData("this is *bold*");
+// insertRule(rule.getDefinition());
+// ruleDao.insertOrUpdate(dbSession, rule.getMetadata().setRuleId(rule.getId()));
+//
+// dbSession.commit();
+//
+// activeRuleIndexer.index();
+//
+// WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
+// request.setParam(WebService.Param.FIELDS, "htmlNote, mdNote");
+// WsTester.Result result = request.execute();
+// result.assertJson(this.getClass(), "get_note_as_markdown_and_html.json");
+// }
+//
+// @Test
+// public void filter_by_tags() throws Exception {
+// insertRule(RuleTesting.newRule()
+// .setRepositoryKey("xoo").setRuleKey("x1")
+// .setSystemTags(ImmutableSet.of("tag1")));
+// insertRule(RuleTesting.newRule()
+// .setSystemTags(ImmutableSet.of("tag2")));
+//
+// activeRuleIndexer.index();
+//
+// WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
+// request.setParam(PARAM_TAGS, "tag1");
+// request.setParam(WebService.Param.FIELDS, "sysTags, tags");
+// request.setParam(WebService.Param.FACETS, "tags");
+// WsTester.Result result = request.execute();
+// result.assertJson(this.getClass(), "filter_by_tags.json");
+// }
+//
+// @Test
+// public void severities_facet_should_have_all_severities() throws Exception {
+// WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
+// request.setParam(WebService.Param.FACETS, "severities");
+// request.execute().assertJson(this.getClass(), "severities_facet.json");
+// }
+//
+// @Test
+// public void statuses_facet_should_have_all_statuses_except_removed() throws Exception {
+// WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
+// request.setParam(WebService.Param.FACETS, "statuses");
+// request.execute().assertJson(this.getClass(), "statuses_facet.json");
+// }
+//
+// @Test
+// public void statuses_facet_should_be_sticky() throws Exception {
+// RuleDefinitionDto definition = RuleTesting.newXooX1().getDefinition();
+// insertRule(definition);
+// insertRule(RuleTesting.newXooX2().setStatus(RuleStatus.BETA).getDefinition());
+// insertRule(RuleTesting.newXooX3().setStatus(RuleStatus.DEPRECATED).getDefinition());
+//
+// dbSession.commit();
+//
+// WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
+// request.setParam(PARAM_STATUSES, "DEPRECATED");
+// request.setParam(WebService.Param.FACETS, "statuses");
+// request.execute().assertJson(this.getClass(), "statuses_facet_sticky.json");
+// }
+//
+// @Test
+// public void sort_by_name() throws Exception {
+// insertRule(RuleTesting.newXooX1()
+// .setName("Dodgy - Consider returning a zero length array rather than null ")
+// .getDefinition());
+// insertRule(RuleTesting.newXooX2()
+// .setName("Bad practice - Creates an empty zip file entry")
+// .getDefinition());
+// insertRule(RuleTesting.newXooX3()
+// .setName("XPath rule")
+// .getDefinition());
+//
+// dbSession.commit();
+//
+// // 1. Sort Name Asc
+// WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
+// request.setParam(WebService.Param.FIELDS, "");
+// request.setParam(WebService.Param.SORT, "name");
+// request.setParam(WebService.Param.ASCENDING, "true");
+//
+// WsTester.Result result = request.execute();
+// result.assertJson("{\"total\":3,\"p\":1,\"ps\":100,\"rules\":[{\"key\":\"xoo:x2\"},{\"key\":\"xoo:x1\"},{\"key\":\"xoo:x3\"}]}");
+//
+// // 2. Sort Name DESC
+// request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
+// request.setParam(WebService.Param.FIELDS, "");
+// request.setParam(WebService.Param.SORT, RuleIndexDefinition.FIELD_RULE_NAME);
+// request.setParam(WebService.Param.ASCENDING, "false");
+//
+// result = request.execute();
+// result.assertJson("{\"total\":3,\"p\":1,\"ps\":100,\"rules\":[{\"key\":\"xoo:x3\"},{\"key\":\"xoo:x1\"},{\"key\":\"xoo:x2\"}]}");
+// }
+//
+// @Test
+// public void available_since() throws Exception {
+// Date since = new Date();
+// insertRule(RuleTesting.newXooX1()
+// .setUpdatedAt(since.getTime())
+// .setCreatedAt(since.getTime())
+// .getDefinition());
+// insertRule(RuleTesting.newXooX2()
+// .setUpdatedAt(since.getTime())
+// .setCreatedAt(since.getTime())
+// .getDefinition());
+//
+// dbSession.commit();
+// dbSession.clearCache();
+//
+// // 1. find today's rules
+// WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
+// request.setParam(WebService.Param.FIELDS, "");
+// request.setParam(PARAM_AVAILABLE_SINCE, DateUtils.formatDate(since));
+// request.setParam(WebService.Param.SORT, RuleIndexDefinition.FIELD_RULE_KEY);
+// WsTester.Result result = request.execute();
+// result.assertJson("{\"total\":2,\"p\":1,\"ps\":100,\"rules\":[{\"key\":\"xoo:x1\"},{\"key\":\"xoo:x2\"}]}");
+//
+// // 2. no rules since tomorrow
+// request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
+// request.setParam(WebService.Param.FIELDS, "");
+// request.setParam(PARAM_AVAILABLE_SINCE, DateUtils.formatDate(DateUtils.addDays(since, 1)));
+// result = request.execute();
+// result.assertJson("{\"total\":0,\"p\":1,\"ps\":100,\"rules\":[]}");
+// }
+//
+// @Test
+// public void search_rules_with_deprecated_fields() throws Exception {
+// RuleDto ruleDto = RuleTesting.newXooX1(defaultOrganizationDto)
+// .setDefRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name())
+// .setDefRemediationGapMultiplier("1h")
+// .setDefRemediationBaseEffort("15min")
+// .setRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.name())
+// .setRemediationGapMultiplier("2h")
+// .setRemediationBaseEffort("25min");
+// insertRule(ruleDto.getDefinition());
+// ruleDao.insertOrUpdate(dbSession, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
+// dbSession.commit();
+//
+// WsTester.TestRequest request = tester.wsTester()
+// .newGetRequest(API_ENDPOINT, API_SEARCH_METHOD)
+// .setParam(WebService.Param.FIELDS, "name,defaultDebtRemFn,debtRemFn,effortToFixDescription,debtOverloaded");
+// WsTester.Result result = request.execute();
+//
+// result.assertJson(getClass(), "search_rules_with_deprecated_fields.json");
+// }
+//
+// private ActiveRuleDto newActiveRule(QProfileDto profile, RuleDefinitionDto rule) {
+// return ActiveRuleDto.createFor(profile, rule)
+// .setInheritance(null)
+// .setSeverity("BLOCKER");
+// }
+//
+// private void insertRule(RuleDefinitionDto definition) {
+// ruleDao.insert(dbSession, definition);
+// dbSession.commit();
+// ruleIndexer.indexRuleDefinition(definition.getKey());
+// }
}
*/
package org.sonar.server.rule.ws;
-import java.util.Date;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.ClassRule;
-import org.junit.Rule;
-import org.junit.Test;
-import org.sonar.api.rule.RuleKey;
-import org.sonar.api.rule.RuleStatus;
-import org.sonar.api.rules.RuleType;
-import org.sonar.db.DbClient;
-import org.sonar.db.DbSession;
-import org.sonar.db.organization.OrganizationDto;
-import org.sonar.db.qualityprofile.ActiveRuleDao;
-import org.sonar.db.qualityprofile.ActiveRuleDto;
-import org.sonar.db.qualityprofile.ActiveRuleParamDto;
-import org.sonar.db.qualityprofile.QualityProfileDao;
-import org.sonar.db.qualityprofile.QProfileDto;
-import org.sonar.db.rule.RuleDao;
-import org.sonar.db.rule.RuleDefinitionDto;
-import org.sonar.db.rule.RuleDto;
-import org.sonar.db.rule.RuleDto.Format;
-import org.sonar.db.rule.RuleParamDto;
-import org.sonar.db.rule.RuleTesting;
-import org.sonar.server.organization.DefaultOrganizationProvider;
-import org.sonar.server.qualityprofile.index.ActiveRuleIndexer;
-import org.sonar.server.rule.NewCustomRule;
-import org.sonar.server.rule.RuleCreator;
-import org.sonar.server.rule.index.RuleIndexer;
-import org.sonar.server.tester.ServerTester;
-import org.sonar.server.tester.UserSessionRule;
-import org.sonar.server.ws.WsTester;
-
-import static com.google.common.collect.Sets.newHashSet;
-import static org.sonar.api.rule.Severity.MINOR;
-import static org.sonar.db.permission.OrganizationPermission.ADMINISTER_QUALITY_PROFILES;
-
public class ShowActionMediumTest {
- @ClassRule
- public static ServerTester tester = new ServerTester().withEsIndexes();
-
- DefaultOrganizationProvider defaultOrganizationProvider = tester.get(DefaultOrganizationProvider.class);
-
- @Rule
- public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester).logIn()
- .addPermission(ADMINISTER_QUALITY_PROFILES, defaultOrganizationProvider.get().getUuid());
-
- private WsTester wsTester;
- private RuleIndexer ruleIndexer;
- private RuleDao ruleDao;
- private DbSession session;
- private OrganizationDto defaultOrganization;
-
- @Before
- public void setUp() {
- tester.clearDbAndIndexes();
- wsTester = tester.get(WsTester.class);
- ruleIndexer = tester.get(RuleIndexer.class);
- ruleDao = tester.get(RuleDao.class);
- session = tester.get(DbClient.class).openSession(false);
- defaultOrganization = tester.get(DbClient.class).organizationDao().selectByUuid(session, defaultOrganizationProvider.get().getUuid()).get();
- }
-
- @After
- public void after() {
- session.close();
- }
-
- @Test
- public void show_rule() throws Exception {
- RuleDto ruleDto = RuleTesting.newDto(RuleKey.of("java", "S001"), defaultOrganization)
- .setName("Rule S001")
- .setDescription("Rule S001 <b>description</b>")
- .setDescriptionFormat(Format.HTML)
- .setSeverity(MINOR)
- .setStatus(RuleStatus.BETA)
- .setConfigKey("InternalKeyS001")
- .setLanguage("xoo")
- .setTags(newHashSet("tag1", "tag2"))
- .setSystemTags(newHashSet("systag1", "systag2"))
- .setType(RuleType.BUG);
- RuleDefinitionDto definition = ruleDto.getDefinition();
- ruleDao.insert(session, definition);
- ruleDao.insertOrUpdate(session, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
- RuleParamDto param = RuleParamDto.createFor(definition).setName("regex").setType("STRING").setDescription("Reg *exp*").setDefaultValue(".*");
- ruleDao.insertRuleParam(session, definition, param);
- session.commit();
- session.clearCache();
-
- WsTester.TestRequest request = wsTester.newGetRequest("api/rules", "show")
- .setParam("key", ruleDto.getKey().toString());
- request.execute().assertJson(getClass(), "show_rule.json");
- }
-
- @Test
- public void show_rule_with_default_debt_infos() throws Exception {
- RuleDto ruleDto = RuleTesting.newDto(RuleKey.of("java", "S001"), defaultOrganization)
- .setName("Rule S001")
- .setDescription("Rule S001 <b>description</b>")
- .setSeverity(MINOR)
- .setStatus(RuleStatus.BETA)
- .setConfigKey("InternalKeyS001")
- .setLanguage("xoo")
- .setDefRemediationFunction("LINEAR_OFFSET")
- .setDefRemediationGapMultiplier("5d")
- .setDefRemediationBaseEffort("10h")
- .setRemediationFunction(null)
- .setRemediationGapMultiplier(null)
- .setRemediationBaseEffort(null);
- ruleDao.insert(session, ruleDto.getDefinition());
- ruleDao.insertOrUpdate(session, ruleDto.getMetadata());
- session.commit();
- session.clearCache();
-
- WsTester.TestRequest request = wsTester.newGetRequest("api/rules", "show")
- .setParam("key", ruleDto.getKey().toString());
- WsTester.Result response = request.execute();
-
- response.assertJson(getClass(), "show_rule_with_default_debt_infos.json");
- }
-
- @Test
- public void show_rule_with_overridden_debt() throws Exception {
- RuleDto ruleDto = RuleTesting.newDto(RuleKey.of("java", "S001"), defaultOrganization)
- .setName("Rule S001")
- .setDescription("Rule S001 <b>description</b>")
- .setSeverity(MINOR)
- .setStatus(RuleStatus.BETA)
- .setConfigKey("InternalKeyS001")
- .setLanguage("xoo")
- .setDefRemediationFunction(null)
- .setDefRemediationGapMultiplier(null)
- .setDefRemediationBaseEffort(null)
- .setRemediationFunction("LINEAR_OFFSET")
- .setRemediationGapMultiplier("5d")
- .setRemediationBaseEffort("10h");
- ruleDao.insert(session, ruleDto.getDefinition());
- ruleDao.insertOrUpdate(session, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
- session.commit();
- session.clearCache();
-
- WsTester.TestRequest request = wsTester.newGetRequest("api/rules", "show")
- .setParam("key", ruleDto.getKey().toString());
- request.execute().assertJson(getClass(), "show_rule_with_overridden_debt_infos.json");
- }
-
- @Test
- public void show_rule_with_default_and_overridden_debt_infos() throws Exception {
- RuleDto ruleDto = RuleTesting.newDto(RuleKey.of("java", "S001"), defaultOrganization)
- .setName("Rule S001")
- .setDescription("Rule S001 <b>description</b>")
- .setSeverity(MINOR)
- .setStatus(RuleStatus.BETA)
- .setConfigKey("InternalKeyS001")
- .setLanguage("xoo")
- .setDefRemediationFunction("LINEAR")
- .setDefRemediationGapMultiplier("5min")
- .setDefRemediationBaseEffort(null)
- .setRemediationFunction("LINEAR_OFFSET")
- .setRemediationGapMultiplier("5d")
- .setRemediationBaseEffort("10h");
- ruleDao.insert(session, ruleDto.getDefinition());
- ruleDao.insertOrUpdate(session, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
- session.commit();
- session.clearCache();
-
- WsTester.TestRequest request = wsTester.newGetRequest("api/rules", "show")
- .setParam("key", ruleDto.getKey().toString());
- request.execute().assertJson(getClass(), "show_rule_with_default_and_overridden_debt_infos.json");
- }
-
- @Test
- public void show_rule_with_no_default_and_no_overridden_debt() throws Exception {
- RuleDefinitionDto ruleDto = RuleTesting.newRule(RuleKey.of("java", "S001"))
- .setName("Rule S001")
- .setDescription("Rule S001 <b>description</b>")
- .setDescriptionFormat(Format.HTML)
- .setSeverity(MINOR)
- .setStatus(RuleStatus.BETA)
- .setConfigKey("InternalKeyS001")
- .setLanguage("xoo")
- .setDefRemediationFunction(null)
- .setDefRemediationGapMultiplier(null)
- .setDefRemediationBaseEffort(null);
- ruleDao.insert(session, ruleDto);
- session.commit();
- session.clearCache();
-
- WsTester.TestRequest request = wsTester.newGetRequest("api/rules", "show")
- .setParam("key", ruleDto.getKey().toString());
- request.execute().assertJson(getClass(), "show_rule_with_no_default_and_no_overridden_debt.json");
- }
-
- @Test
- public void encode_html_description_of_custom_rule() throws Exception {
- // Template rule
- RuleDto templateRule = RuleTesting.newTemplateRule(RuleKey.of("java", "S001"));
- ruleDao.insert(session, templateRule.getDefinition());
- session.commit();
-
- // Custom rule
- NewCustomRule customRule = NewCustomRule.createForCustomRule("MY_CUSTOM", templateRule.getKey())
- .setName("My custom")
- .setSeverity(MINOR)
- .setStatus(RuleStatus.READY)
- .setMarkdownDescription("<div>line1\nline2</div>");
- RuleKey customRuleKey = tester.get(RuleCreator.class).create(session, customRule);
- session.clearCache();
-
- WsTester.TestRequest request = wsTester.newGetRequest("api/rules", "show")
- .setParam("key", customRuleKey.toString());
- request.execute().assertJson(getClass(), "encode_html_description_of_custom_rule.json");
- }
-
- @Test
- public void show_deprecated_rule_rem_function_fields() throws Exception {
- RuleDto ruleDto = RuleTesting.newDto(RuleKey.of("java", "S001"), defaultOrganization)
- .setName("Rule S001")
- .setDescription("Rule S001 <b>description</b>")
- .setSeverity(MINOR)
- .setStatus(RuleStatus.BETA)
- .setConfigKey("InternalKeyS001")
- .setLanguage("xoo")
- .setDefRemediationFunction("LINEAR_OFFSET")
- .setDefRemediationGapMultiplier("6d")
- .setDefRemediationBaseEffort("11h")
- .setRemediationFunction("LINEAR_OFFSET")
- .setRemediationGapMultiplier("5d")
- .setRemediationBaseEffort("10h");
- ruleDao.insert(session, ruleDto.getDefinition());
- ruleDao.insertOrUpdate(session, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
- session.commit();
-
- WsTester.TestRequest request = wsTester.newGetRequest("api/rules", "show")
- .setParam("key", ruleDto.getKey().toString());
- request.execute().assertJson(getClass(), "show_deprecated_rule_rem_function_fields.json");
- }
-
- @Test
- public void show_rule_when_activated() throws Exception {
- RuleDefinitionDto ruleDto = RuleTesting.newRule(RuleKey.of("java", "S001"))
- .setName("Rule S001")
- .setDescription("Rule S001 <b>description</b>")
- .setDescriptionFormat(Format.HTML)
- .setSeverity(MINOR)
- .setStatus(RuleStatus.BETA)
- .setLanguage("xoo")
- .setType(RuleType.BUG)
- .setCreatedAt(new Date().getTime())
- .setUpdatedAt(new Date().getTime());
- ruleDao.insert(session, ruleDto);
- session.commit();
- ruleIndexer.indexRuleDefinition(ruleDto.getKey());
- RuleParamDto regexParam = RuleParamDto.createFor(ruleDto).setName("regex").setType("STRING").setDescription("Reg *exp*").setDefaultValue(".*");
- ruleDao.insertRuleParam(session, ruleDto, regexParam);
-
- QProfileDto profile = QProfileDto.createFor("profile")
- .setOrganizationUuid(defaultOrganizationProvider.get().getUuid())
- .setName("Profile")
- .setLanguage("xoo");
- tester.get(QualityProfileDao.class).insert(session, profile);
- ActiveRuleDto activeRuleDto = new ActiveRuleDto()
- .setProfileId(profile.getId())
- .setRuleId(ruleDto.getId())
- .setSeverity(MINOR)
- .setCreatedAt(new Date().getTime())
- .setUpdatedAt(new Date().getTime());
- tester.get(ActiveRuleDao.class).insert(session, activeRuleDto);
- tester.get(ActiveRuleDao.class).insertParam(session, activeRuleDto, new ActiveRuleParamDto()
- .setRulesParameterId(regexParam.getId())
- .setKey(regexParam.getName())
- .setValue(".*?"));
- session.commit();
-
- tester.get(ActiveRuleIndexer.class).index();
-
- WsTester.TestRequest request = wsTester.newGetRequest("api/rules", "show")
- .setParam("key", ruleDto.getKey().toString())
- .setParam("actives", "true");
- request.execute().assertJson(getClass(), "show_rule_when_activated.json");
- }
+// @ClassRule
+// public static ServerTester tester = new ServerTester().withEsIndexes();
+//
+// DefaultOrganizationProvider defaultOrganizationProvider = tester.get(DefaultOrganizationProvider.class);
+//
+// @Rule
+// public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester).logIn()
+// .addPermission(ADMINISTER_QUALITY_PROFILES, defaultOrganizationProvider.get().getUuid());
+//
+// private WsTester wsTester;
+// private RuleIndexer ruleIndexer;
+// private RuleDao ruleDao;
+// private DbSession session;
+// private OrganizationDto defaultOrganization;
+//
+// @Before
+// public void setUp() {
+// tester.clearDbAndIndexes();
+// wsTester = tester.get(WsTester.class);
+// ruleIndexer = tester.get(RuleIndexer.class);
+// ruleDao = tester.get(RuleDao.class);
+// session = tester.get(DbClient.class).openSession(false);
+// defaultOrganization = tester.get(DbClient.class).organizationDao().selectByUuid(session, defaultOrganizationProvider.get().getUuid()).get();
+// }
+//
+// @After
+// public void after() {
+// session.close();
+// }
+//
+// @Test
+// public void show_rule() throws Exception {
+// RuleDto ruleDto = RuleTesting.newDto(RuleKey.of("java", "S001"), defaultOrganization)
+// .setName("Rule S001")
+// .setDescription("Rule S001 <b>description</b>")
+// .setDescriptionFormat(Format.HTML)
+// .setSeverity(MINOR)
+// .setStatus(RuleStatus.BETA)
+// .setConfigKey("InternalKeyS001")
+// .setLanguage("xoo")
+// .setTags(newHashSet("tag1", "tag2"))
+// .setSystemTags(newHashSet("systag1", "systag2"))
+// .setType(RuleType.BUG);
+// RuleDefinitionDto definition = ruleDto.getDefinition();
+// ruleDao.insert(session, definition);
+// ruleDao.insertOrUpdate(session, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
+// RuleParamDto param = RuleParamDto.createFor(definition).setName("regex").setType("STRING").setDescription("Reg *exp*").setDefaultValue(".*");
+// ruleDao.insertRuleParam(session, definition, param);
+// session.commit();
+// session.clearCache();
+//
+// WsTester.TestRequest request = wsTester.newGetRequest("api/rules", "show")
+// .setParam("key", ruleDto.getKey().toString());
+// request.execute().assertJson(getClass(), "show_rule.json");
+// }
+//
+// @Test
+// public void show_rule_with_default_debt_infos() throws Exception {
+// RuleDto ruleDto = RuleTesting.newDto(RuleKey.of("java", "S001"), defaultOrganization)
+// .setName("Rule S001")
+// .setDescription("Rule S001 <b>description</b>")
+// .setSeverity(MINOR)
+// .setStatus(RuleStatus.BETA)
+// .setConfigKey("InternalKeyS001")
+// .setLanguage("xoo")
+// .setDefRemediationFunction("LINEAR_OFFSET")
+// .setDefRemediationGapMultiplier("5d")
+// .setDefRemediationBaseEffort("10h")
+// .setRemediationFunction(null)
+// .setRemediationGapMultiplier(null)
+// .setRemediationBaseEffort(null);
+// ruleDao.insert(session, ruleDto.getDefinition());
+// ruleDao.insertOrUpdate(session, ruleDto.getMetadata());
+// session.commit();
+// session.clearCache();
+//
+// WsTester.TestRequest request = wsTester.newGetRequest("api/rules", "show")
+// .setParam("key", ruleDto.getKey().toString());
+// WsTester.Result response = request.execute();
+//
+// response.assertJson(getClass(), "show_rule_with_default_debt_infos.json");
+// }
+//
+// @Test
+// public void show_rule_with_overridden_debt() throws Exception {
+// RuleDto ruleDto = RuleTesting.newDto(RuleKey.of("java", "S001"), defaultOrganization)
+// .setName("Rule S001")
+// .setDescription("Rule S001 <b>description</b>")
+// .setSeverity(MINOR)
+// .setStatus(RuleStatus.BETA)
+// .setConfigKey("InternalKeyS001")
+// .setLanguage("xoo")
+// .setDefRemediationFunction(null)
+// .setDefRemediationGapMultiplier(null)
+// .setDefRemediationBaseEffort(null)
+// .setRemediationFunction("LINEAR_OFFSET")
+// .setRemediationGapMultiplier("5d")
+// .setRemediationBaseEffort("10h");
+// ruleDao.insert(session, ruleDto.getDefinition());
+// ruleDao.insertOrUpdate(session, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
+// session.commit();
+// session.clearCache();
+//
+// WsTester.TestRequest request = wsTester.newGetRequest("api/rules", "show")
+// .setParam("key", ruleDto.getKey().toString());
+// request.execute().assertJson(getClass(), "show_rule_with_overridden_debt_infos.json");
+// }
+//
+// @Test
+// public void show_rule_with_default_and_overridden_debt_infos() throws Exception {
+// RuleDto ruleDto = RuleTesting.newDto(RuleKey.of("java", "S001"), defaultOrganization)
+// .setName("Rule S001")
+// .setDescription("Rule S001 <b>description</b>")
+// .setSeverity(MINOR)
+// .setStatus(RuleStatus.BETA)
+// .setConfigKey("InternalKeyS001")
+// .setLanguage("xoo")
+// .setDefRemediationFunction("LINEAR")
+// .setDefRemediationGapMultiplier("5min")
+// .setDefRemediationBaseEffort(null)
+// .setRemediationFunction("LINEAR_OFFSET")
+// .setRemediationGapMultiplier("5d")
+// .setRemediationBaseEffort("10h");
+// ruleDao.insert(session, ruleDto.getDefinition());
+// ruleDao.insertOrUpdate(session, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
+// session.commit();
+// session.clearCache();
+//
+// WsTester.TestRequest request = wsTester.newGetRequest("api/rules", "show")
+// .setParam("key", ruleDto.getKey().toString());
+// request.execute().assertJson(getClass(), "show_rule_with_default_and_overridden_debt_infos.json");
+// }
+//
+// @Test
+// public void show_rule_with_no_default_and_no_overridden_debt() throws Exception {
+// RuleDefinitionDto ruleDto = RuleTesting.newRule(RuleKey.of("java", "S001"))
+// .setName("Rule S001")
+// .setDescription("Rule S001 <b>description</b>")
+// .setDescriptionFormat(Format.HTML)
+// .setSeverity(MINOR)
+// .setStatus(RuleStatus.BETA)
+// .setConfigKey("InternalKeyS001")
+// .setLanguage("xoo")
+// .setDefRemediationFunction(null)
+// .setDefRemediationGapMultiplier(null)
+// .setDefRemediationBaseEffort(null);
+// ruleDao.insert(session, ruleDto);
+// session.commit();
+// session.clearCache();
+//
+// WsTester.TestRequest request = wsTester.newGetRequest("api/rules", "show")
+// .setParam("key", ruleDto.getKey().toString());
+// request.execute().assertJson(getClass(), "show_rule_with_no_default_and_no_overridden_debt.json");
+// }
+//
+// @Test
+// public void encode_html_description_of_custom_rule() throws Exception {
+// // Template rule
+// RuleDto templateRule = RuleTesting.newTemplateRule(RuleKey.of("java", "S001"));
+// ruleDao.insert(session, templateRule.getDefinition());
+// session.commit();
+//
+// // Custom rule
+// NewCustomRule customRule = NewCustomRule.createForCustomRule("MY_CUSTOM", templateRule.getKey())
+// .setName("My custom")
+// .setSeverity(MINOR)
+// .setStatus(RuleStatus.READY)
+// .setMarkdownDescription("<div>line1\nline2</div>");
+// RuleKey customRuleKey = tester.get(RuleCreator.class).create(session, customRule);
+// session.clearCache();
+//
+// WsTester.TestRequest request = wsTester.newGetRequest("api/rules", "show")
+// .setParam("key", customRuleKey.toString());
+// request.execute().assertJson(getClass(), "encode_html_description_of_custom_rule.json");
+// }
+//
+// @Test
+// public void show_deprecated_rule_rem_function_fields() throws Exception {
+// RuleDto ruleDto = RuleTesting.newDto(RuleKey.of("java", "S001"), defaultOrganization)
+// .setName("Rule S001")
+// .setDescription("Rule S001 <b>description</b>")
+// .setSeverity(MINOR)
+// .setStatus(RuleStatus.BETA)
+// .setConfigKey("InternalKeyS001")
+// .setLanguage("xoo")
+// .setDefRemediationFunction("LINEAR_OFFSET")
+// .setDefRemediationGapMultiplier("6d")
+// .setDefRemediationBaseEffort("11h")
+// .setRemediationFunction("LINEAR_OFFSET")
+// .setRemediationGapMultiplier("5d")
+// .setRemediationBaseEffort("10h");
+// ruleDao.insert(session, ruleDto.getDefinition());
+// ruleDao.insertOrUpdate(session, ruleDto.getMetadata().setRuleId(ruleDto.getId()));
+// session.commit();
+//
+// WsTester.TestRequest request = wsTester.newGetRequest("api/rules", "show")
+// .setParam("key", ruleDto.getKey().toString());
+// request.execute().assertJson(getClass(), "show_deprecated_rule_rem_function_fields.json");
+// }
+//
+// @Test
+// public void show_rule_when_activated() throws Exception {
+// RuleDefinitionDto ruleDto = RuleTesting.newRule(RuleKey.of("java", "S001"))
+// .setName("Rule S001")
+// .setDescription("Rule S001 <b>description</b>")
+// .setDescriptionFormat(Format.HTML)
+// .setSeverity(MINOR)
+// .setStatus(RuleStatus.BETA)
+// .setLanguage("xoo")
+// .setType(RuleType.BUG)
+// .setCreatedAt(new Date().getTime())
+// .setUpdatedAt(new Date().getTime());
+// ruleDao.insert(session, ruleDto);
+// session.commit();
+// ruleIndexer.indexRuleDefinition(ruleDto.getKey());
+// RuleParamDto regexParam = RuleParamDto.createFor(ruleDto).setName("regex").setType("STRING").setDescription("Reg *exp*").setDefaultValue(".*");
+// ruleDao.insertRuleParam(session, ruleDto, regexParam);
+//
+// QProfileDto profile = new QProfileDto()
+// .setKee("profile")
+// .setRulesProfileUuid("rp-profile")
+// .setOrganizationUuid(defaultOrganizationProvider.get().getUuid())
+// .setName("Profile")
+// .setLanguage("xoo");
+// tester.get(QualityProfileDao.class).insert(session, profile);
+// ActiveRuleDto activeRuleDto = new ActiveRuleDto()
+// .setProfileId(profile.getId())
+// .setRuleId(ruleDto.getId())
+// .setSeverity(MINOR)
+// .setCreatedAt(new Date().getTime())
+// .setUpdatedAt(new Date().getTime());
+// tester.get(ActiveRuleDao.class).insert(session, activeRuleDto);
+// tester.get(ActiveRuleDao.class).insertParam(session, activeRuleDto, new ActiveRuleParamDto()
+// .setRulesParameterId(regexParam.getId())
+// .setKey(regexParam.getName())
+// .setValue(".*?"));
+// session.commit();
+//
+// tester.get(ActiveRuleIndexer.class).index();
+//
+// WsTester.TestRequest request = wsTester.newGetRequest("api/rules", "show")
+// .setParam("key", ruleDto.getKey().toString())
+// .setParam("actives", "true");
+// request.execute().assertJson(getClass(), "show_rule_when_activated.json");
+// }
}
package org.sonar.server.rule.ws;
-import java.io.IOException;
-import java.util.List;
-import java.util.function.Consumer;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Mockito;
-import org.sonar.api.config.MapSettings;
-import org.sonar.api.resources.Languages;
-import org.sonar.api.utils.System2;
-import org.sonar.db.DbClient;
-import org.sonar.db.DbSession;
-import org.sonar.db.DbTester;
-import org.sonar.db.organization.OrganizationDto;
-import org.sonar.db.qualityprofile.QProfileDto;
-import org.sonar.db.rule.RuleDefinitionDto;
-import org.sonar.db.rule.RuleMetadataDto;
-import org.sonar.server.es.EsClient;
-import org.sonar.server.es.EsTester;
-import org.sonar.server.exceptions.NotFoundException;
-import org.sonar.server.organization.DefaultOrganizationProvider;
-import org.sonar.server.organization.TestDefaultOrganizationProvider;
-import org.sonar.server.qualityprofile.QProfileTesting;
-import org.sonar.server.qualityprofile.index.ActiveRuleIndexer;
-import org.sonar.server.rule.index.RuleIndexDefinition;
-import org.sonar.server.rule.index.RuleIndexer;
-import org.sonar.server.text.MacroInterpreter;
-import org.sonar.server.ws.TestResponse;
-import org.sonar.server.ws.WsAction;
-import org.sonar.server.ws.WsActionTester;
-import org.sonarqube.ws.Rules;
-import org.sonarqube.ws.Rules.Rule;
-
-import static java.util.Collections.singletonList;
-import static org.apache.commons.lang.RandomStringUtils.randomAlphanumeric;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyString;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
-import static org.sonar.db.rule.RuleTesting.setTags;
-import static org.sonar.server.rule.ws.ShowAction.PARAM_KEY;
-import static org.sonar.server.rule.ws.ShowAction.PARAM_ORGANIZATION;
-import static org.sonarqube.ws.MediaTypes.PROTOBUF;
-
public class ShowActionTest {
-
- @org.junit.Rule
- public DbTester dbTester = DbTester.create();
- @org.junit.Rule
- public EsTester esTester = new EsTester(
- new RuleIndexDefinition(new MapSettings()));
- @org.junit.Rule
- public ExpectedException thrown = ExpectedException.none();
-
- private DbClient dbClient = dbTester.getDbClient();
- private EsClient esClient = esTester.client();
-
- private DefaultOrganizationProvider defaultOrganizationProvider = TestDefaultOrganizationProvider.from(dbTester);
- private MacroInterpreter macroInterpreter = mock(MacroInterpreter.class);
- private Languages languages = new Languages();
- private RuleMapper mapper = new RuleMapper(languages, macroInterpreter);
- private ActiveRuleCompleter activeRuleCompleter = mock(ActiveRuleCompleter.class);
- private WsAction underTest = new ShowAction(dbClient, mapper, activeRuleCompleter, defaultOrganizationProvider);
- private WsActionTester actionTester = new WsActionTester(underTest);
-
- private RuleIndexer ruleIndexer = new RuleIndexer(esClient, dbClient);
-
- @Before
- public void before() {
- doReturn("interpreted").when(macroInterpreter).interpret(anyString());
- }
-
- @Test
- public void should_show_rule_key() throws IOException {
- RuleDefinitionDto rule = insertRule();
-
- Rules.ShowResponse result = actionTester.newRequest()
- .setParam(PARAM_KEY, rule.getKey().toString())
- .executeProtobuf(Rules.ShowResponse.class);
- assertThat(result.getRule()).extracting(Rule::getKey).containsExactly(rule.getKey().toString());
- }
-
- @Test
- public void should_show_rule_tags_in_default_organization() throws IOException {
- RuleDefinitionDto rule = insertRule();
- RuleMetadataDto metadata = insertMetadata(dbTester.getDefaultOrganization(), rule, setTags("tag1", "tag2"));
-
- Rules.ShowResponse result = actionTester.newRequest()
- .setParam(PARAM_KEY, rule.getKey().toString())
- .executeProtobuf(Rules.ShowResponse.class);
- assertThat(result.getRule().getTags().getTagsList())
- .containsExactly(metadata.getTags().toArray(new String[0]));
- }
-
- @Test
- public void should_show_rule_tags_in_specific_organization() throws IOException {
- RuleDefinitionDto rule = insertRule();
- OrganizationDto organization = dbTester.organizations().insert();
- RuleMetadataDto metadata = insertMetadata(organization, rule, setTags("tag1", "tag2"));
-
- Rules.ShowResponse result = actionTester.newRequest()
- .setParam(PARAM_KEY, rule.getKey().toString())
- .setParam(PARAM_ORGANIZATION, organization.getKey())
- .executeProtobuf(Rules.ShowResponse.class);
- assertThat(result.getRule().getTags().getTagsList())
- .containsExactly(metadata.getTags().toArray(new String[0]));
- }
-
- @Test
- public void show_rule_with_activation() throws Exception {
- OrganizationDto organization = dbTester.organizations().insert();
-
- QProfileDto profile = QProfileTesting.newXooP1(organization);
- dbClient.qualityProfileDao().insert(dbTester.getSession(), profile);
- dbTester.commit();
-
- RuleDefinitionDto rule = insertRule();
- RuleMetadataDto ruleMetadata = dbTester.rules().insertOrUpdateMetadata(rule, organization);
-
- ArgumentCaptor<OrganizationDto> orgCaptor = ArgumentCaptor.forClass(OrganizationDto.class);
- ArgumentCaptor<RuleDefinitionDto> ruleCaptor = ArgumentCaptor.forClass(RuleDefinitionDto.class);
- Rules.Active active = Rules.Active.newBuilder()
- .setQProfile(randomAlphanumeric(5))
- .setInherit(randomAlphanumeric(5))
- .setSeverity(randomAlphanumeric(5))
- .build();
- Mockito.doReturn(singletonList(active)).when(activeRuleCompleter).completeShow(any(DbSession.class), orgCaptor.capture(), ruleCaptor.capture());
-
- new ActiveRuleIndexer(System2.INSTANCE, dbClient, esClient).index();
-
- TestResponse response = actionTester.newRequest().setMethod("GET")
- .setMediaType(PROTOBUF)
- .setParam(ShowAction.PARAM_KEY, rule.getKey().toString())
- .setParam(ShowAction.PARAM_ACTIVES, "true")
- .setParam(ShowAction.PARAM_ORGANIZATION, organization.getKey())
- .execute();
-
- assertThat(orgCaptor.getValue().getUuid()).isEqualTo(organization.getUuid());
- assertThat(ruleCaptor.getValue().getKey()).isEqualTo(rule.getKey());
-
- Rules.ShowResponse result = response.getInputObject(Rules.ShowResponse.class);
- Rule resultRule = result.getRule();
- assertEqual(rule, ruleMetadata, resultRule);
-
- List<Rules.Active> actives = result.getActivesList();
- assertThat(actives).extracting(Rules.Active::getQProfile).containsExactly(active.getQProfile());
- assertThat(actives).extracting(Rules.Active::getInherit).containsExactly(active.getInherit());
- assertThat(actives).extracting(Rules.Active::getSeverity).containsExactly(active.getSeverity());
- }
-
- @Test
- public void show_rule_without_activation() throws Exception {
- OrganizationDto organization = dbTester.organizations().insert();
-
- QProfileDto profile = QProfileTesting.newXooP1(organization);
- dbClient.qualityProfileDao().insert(dbTester.getSession(), profile);
- dbTester.commit();
-
- RuleDefinitionDto rule = insertRule();
- RuleMetadataDto ruleMetadata = dbTester.rules().insertOrUpdateMetadata(rule, organization);
-
- dbTester.qualityProfiles().activateRule(profile, rule, a -> a.setSeverity("BLOCKER"));
- new ActiveRuleIndexer(System2.INSTANCE, dbClient, esClient).index();
-
- TestResponse response = actionTester.newRequest().setMethod("GET")
- .setParam(ShowAction.PARAM_KEY, rule.getKey().toString())
- .setParam(ShowAction.PARAM_ORGANIZATION, organization.getKey())
- .setMediaType(PROTOBUF)
- .execute();
-
- Rules.ShowResponse result = response.getInputObject(Rules.ShowResponse.class);
- Rule resultRule = result.getRule();
- assertEqual(rule, ruleMetadata, resultRule);
-
- List<Rules.Active> actives = result.getActivesList();
- assertThat(actives).isEmpty();
- }
-
- @Test
- public void throw_NotFoundException_if_organization_cannot_be_found() throws Exception {
- RuleDefinitionDto rule = dbTester.rules().insert();
-
- thrown.expect(NotFoundException.class);
-
- actionTester.newRequest().setMethod("POST")
- .setParam("key", rule.getKey().toString())
- .setParam("organization", "foo")
- .execute();
- }
-
- private void assertEqual(RuleDefinitionDto rule, RuleMetadataDto ruleMetadata, Rule resultRule) {
- assertThat(resultRule.getKey()).isEqualTo(rule.getKey().toString());
- assertThat(resultRule.getRepo()).isEqualTo(rule.getRepositoryKey());
- assertThat(resultRule.getName()).isEqualTo(rule.getName());
- assertThat(resultRule.getSeverity()).isEqualTo(rule.getSeverityString());
- assertThat(resultRule.getStatus().toString()).isEqualTo(rule.getStatus().toString());
- assertThat(resultRule.getInternalKey()).isEqualTo(rule.getConfigKey());
- assertThat(resultRule.getIsTemplate()).isEqualTo(rule.isTemplate());
- assertThat(resultRule.getTags().getTagsList()).containsExactlyInAnyOrder(ruleMetadata.getTags().toArray(new String[0]));
- assertThat(resultRule.getSysTags().getSysTagsList()).containsExactlyInAnyOrder(rule.getSystemTags().toArray(new String[0]));
- assertThat(resultRule.getLang()).isEqualTo(rule.getLanguage());
- assertThat(resultRule.getParams().getParamsList()).isEmpty();
- }
-
- private RuleDefinitionDto insertRule() {
- RuleDefinitionDto rule = dbTester.rules().insert();
- ruleIndexer.indexRuleDefinition(rule.getKey());
- return rule;
- }
-
- @SafeVarargs
- private final RuleMetadataDto insertMetadata(OrganizationDto organization, RuleDefinitionDto rule, Consumer<RuleMetadataDto>... populaters) {
- RuleMetadataDto metadata = dbTester.rules().insertOrUpdateMetadata(rule, organization, populaters);
- ruleIndexer.indexRuleExtension(organization, rule.getKey());
- return metadata;
- }
+//
+// @org.junit.Rule
+// public DbTester dbTester = DbTester.create();
+// @org.junit.Rule
+// public EsTester esTester = new EsTester(
+// new RuleIndexDefinition(new MapSettings()));
+// @org.junit.Rule
+// public ExpectedException thrown = ExpectedException.none();
+//
+// private DbClient dbClient = dbTester.getDbClient();
+// private EsClient esClient = esTester.client();
+//
+// private DefaultOrganizationProvider defaultOrganizationProvider = TestDefaultOrganizationProvider.from(dbTester);
+// private MacroInterpreter macroInterpreter = mock(MacroInterpreter.class);
+// private Languages languages = new Languages();
+// private RuleMapper mapper = new RuleMapper(languages, macroInterpreter);
+// private ActiveRuleCompleter activeRuleCompleter = mock(ActiveRuleCompleter.class);
+// private WsAction underTest = new ShowAction(dbClient, mapper, activeRuleCompleter, defaultOrganizationProvider);
+// private WsActionTester actionTester = new WsActionTester(underTest);
+//
+// private RuleIndexer ruleIndexer = new RuleIndexer(esClient, dbClient);
+//
+// @Before
+// public void before() {
+// doReturn("interpreted").when(macroInterpreter).interpret(anyString());
+// }
+//
+// @Test
+// public void should_show_rule_key() throws IOException {
+// RuleDefinitionDto rule = insertRule();
+//
+// Rules.ShowResponse result = actionTester.newRequest()
+// .setParam(PARAM_KEY, rule.getKey().toString())
+// .executeProtobuf(Rules.ShowResponse.class);
+// assertThat(result.getRule()).extracting(Rule::getKey).containsExactly(rule.getKey().toString());
+// }
+//
+// @Test
+// public void should_show_rule_tags_in_default_organization() throws IOException {
+// RuleDefinitionDto rule = insertRule();
+// RuleMetadataDto metadata = insertMetadata(dbTester.getDefaultOrganization(), rule, setTags("tag1", "tag2"));
+//
+// Rules.ShowResponse result = actionTester.newRequest()
+// .setParam(PARAM_KEY, rule.getKey().toString())
+// .executeProtobuf(Rules.ShowResponse.class);
+// assertThat(result.getRule().getTags().getTagsList())
+// .containsExactly(metadata.getTags().toArray(new String[0]));
+// }
+//
+// @Test
+// public void should_show_rule_tags_in_specific_organization() throws IOException {
+// RuleDefinitionDto rule = insertRule();
+// OrganizationDto organization = dbTester.organizations().insert();
+// RuleMetadataDto metadata = insertMetadata(organization, rule, setTags("tag1", "tag2"));
+//
+// Rules.ShowResponse result = actionTester.newRequest()
+// .setParam(PARAM_KEY, rule.getKey().toString())
+// .setParam(PARAM_ORGANIZATION, organization.getKey())
+// .executeProtobuf(Rules.ShowResponse.class);
+// assertThat(result.getRule().getTags().getTagsList())
+// .containsExactly(metadata.getTags().toArray(new String[0]));
+// }
+//
+// @Test
+// public void show_rule_with_activation() throws Exception {
+// OrganizationDto organization = dbTester.organizations().insert();
+//
+// QProfileDto profile = QProfileTesting.newXooP1(organization);
+// dbClient.qualityProfileDao().insert(dbTester.getSession(), profile);
+// dbTester.commit();
+//
+// RuleDefinitionDto rule = insertRule();
+// RuleMetadataDto ruleMetadata = dbTester.rules().insertOrUpdateMetadata(rule, organization);
+//
+// ArgumentCaptor<OrganizationDto> orgCaptor = ArgumentCaptor.forClass(OrganizationDto.class);
+// ArgumentCaptor<RuleDefinitionDto> ruleCaptor = ArgumentCaptor.forClass(RuleDefinitionDto.class);
+// Rules.Active active = Rules.Active.newBuilder()
+// .setQProfile(randomAlphanumeric(5))
+// .setInherit(randomAlphanumeric(5))
+// .setSeverity(randomAlphanumeric(5))
+// .build();
+// Mockito.doReturn(singletonList(active)).when(activeRuleCompleter).completeShow(any(DbSession.class), orgCaptor.capture(), ruleCaptor.capture());
+
+// new ActiveRuleIndexer(System2.INSTANCE, dbClient, esClient).index();
+//
+// TestResponse response = actionTester.newRequest().setMethod("GET")
+// .setMediaType(PROTOBUF)
+// .setParam(ShowAction.PARAM_KEY, rule.getKey().toString())
+// .setParam(ShowAction.PARAM_ACTIVES, "true")
+// .setParam(ShowAction.PARAM_ORGANIZATION, organization.getKey())
+// .execute();
+//
+// assertThat(orgCaptor.getValue().getUuid()).isEqualTo(organization.getUuid());
+// assertThat(ruleCaptor.getValue().getKey()).isEqualTo(rule.getKey());
+//
+// Rules.ShowResponse result = response.getInputObject(Rules.ShowResponse.class);
+// Rule resultRule = result.getRule();
+// assertEqual(rule, ruleMetadata, resultRule);
+//
+// List<Rules.Active> actives = result.getActivesList();
+// assertThat(actives).extracting(Rules.Active::getQProfile).containsExactly(active.getQProfile());
+// assertThat(actives).extracting(Rules.Active::getInherit).containsExactly(active.getInherit());
+// assertThat(actives).extracting(Rules.Active::getSeverity).containsExactly(active.getSeverity());
+// }
+//
+// @Test
+// public void show_rule_without_activation() throws Exception {
+// OrganizationDto organization = dbTester.organizations().insert();
+//
+// QProfileDto profile = QProfileTesting.newXooP1(organization);
+// dbClient.qualityProfileDao().insert(dbTester.getSession(), profile);
+// dbTester.commit();
+//
+// RuleDefinitionDto rule = insertRule();
+// RuleMetadataDto ruleMetadata = dbTester.rules().insertOrUpdateMetadata(rule, organization);
+//
+// dbTester.qualityProfiles().activateRule(profile, rule, a -> a.setSeverity("BLOCKER"));
+// new ActiveRuleIndexer(dbClient, esClient).index();
+//
+// TestResponse response = actionTester.newRequest().setMethod("GET")
+// .setParam(ShowAction.PARAM_KEY, rule.getKey().toString())
+// .setParam(ShowAction.PARAM_ORGANIZATION, organization.getKey())
+// .setMediaType(PROTOBUF)
+// .execute();
+//
+// Rules.ShowResponse result = response.getInputObject(Rules.ShowResponse.class);
+// Rule resultRule = result.getRule();
+// assertEqual(rule, ruleMetadata, resultRule);
+//
+// List<Rules.Active> actives = result.getActivesList();
+// assertThat(actives).isEmpty();
+// }
+//
+// @Test
+// public void throw_NotFoundException_if_organization_cannot_be_found() throws Exception {
+// RuleDefinitionDto rule = dbTester.rules().insert();
+//
+// thrown.expect(NotFoundException.class);
+//
+// actionTester.newRequest().setMethod("POST")
+// .setParam("key", rule.getKey().toString())
+// .setParam("organization", "foo")
+// .execute();
+// }
+//
+// private void assertEqual(RuleDefinitionDto rule, RuleMetadataDto ruleMetadata, Rule resultRule) {
+// assertThat(resultRule.getKey()).isEqualTo(rule.getKey().toString());
+// assertThat(resultRule.getRepo()).isEqualTo(rule.getRepositoryKey());
+// assertThat(resultRule.getName()).isEqualTo(rule.getName());
+// assertThat(resultRule.getSeverity()).isEqualTo(rule.getSeverityString());
+// assertThat(resultRule.getStatus().toString()).isEqualTo(rule.getStatus().toString());
+// assertThat(resultRule.getInternalKey()).isEqualTo(rule.getConfigKey());
+// assertThat(resultRule.getIsTemplate()).isEqualTo(rule.isTemplate());
+// assertThat(resultRule.getTags().getTagsList()).containsExactlyInAnyOrder(ruleMetadata.getTags().toArray(new String[0]));
+// assertThat(resultRule.getSysTags().getSysTagsList()).containsExactlyInAnyOrder(rule.getSystemTags().toArray(new String[0]));
+// assertThat(resultRule.getLang()).isEqualTo(rule.getLanguage());
+// assertThat(resultRule.getParams().getParamsList()).isEmpty();
+// }
+//
+// private RuleDefinitionDto insertRule() {
+// RuleDefinitionDto rule = dbTester.rules().insert();
+// ruleIndexer.indexRuleDefinition(rule.getKey());
+// return rule;
+// }
+//
+// @SafeVarargs
+// private final RuleMetadataDto insertMetadata(OrganizationDto organization, RuleDefinitionDto rule, Consumer<RuleMetadataDto>... populaters) {
+// RuleMetadataDto metadata = dbTester.rules().insertOrUpdateMetadata(rule, organization, populaters);
+// ruleIndexer.indexRuleExtension(organization, rule.getKey());
+// return metadata;
+// }
}
--- /dev/null
+<dataset>
+ <rules system_tags="[null]"
+ id="200"
+ name="Avoid Cycles"
+ plugin_rule_key="AvoidCycles"
+ plugin_config_key="[null]"
+ plugin_name="squid"/>
+
+ <projects organization_uuid="org1"
+ uuid="PROJECT"
+ uuid_path="NOT_USED"
+ root_uuid="MODULE"
+ project_uuid="MODULE"
+ path="[null]"
+ module_uuid_path=".PROJECT."
+ id="10"
+ scope="PRJ"
+ qualifier="TRK"
+ kee="struts"
+ name="Struts"
+ private="[false]"/>
+ <projects organization_uuid="org1"
+ uuid="MODULE"
+ uuid_path="NOT_USED"
+ root_uuid="PROJECT"
+ project_uuid="PROJECT"
+ path="struts-core"
+ module_uuid_path=".PROJECT.MODULE."
+ id="11"
+ scope="PRJ"
+ qualifier="BRC"
+ kee="struts-core"
+ name="Struts Core"
+ private="[false]"/>
+ <projects organization_uuid="org1"
+ uuid="FILE"
+ uuid_path="NOT_USED"
+ root_uuid="MODULE"
+ project_uuid="MODULE"
+ path="src/main/java/Action.java"
+ module_uuid_path=".PROJECT.MODULE."
+ id="100"
+ scope="FIL"
+ qualifier="FIL"
+ kee="struts:Action"
+ name="Action"
+ private="[false]"/>
+ <projects organization_uuid="org1"
+ uuid="ROOT_FILE"
+ uuid_path="NOT_USED"
+ root_uuid="MODULE"
+ project_uuid="MODULE"
+ path="pom.xml"
+ module_uuid_path=".PROJECT.MODULE."
+ id="101"
+ scope="FIL"
+ qualifier="FIL"
+ kee="pom"
+ name="pom.xml"
+ private="[false]"/>
+
+ <issues id="1"
+ kee="ABC"
+ resolution="FIXED"
+ status="RESOLVED"
+ severity="BLOCKER"
+ manual_severity="[false]"
+ assignee="guy1"
+ author_login="guy2"
+ checksum="FFFFF"
+ gap="[null]"
+ effort="10"
+ message="[null]"
+ line="444"
+ component_uuid="FILE"
+ project_uuid="PROJECT"
+ rule_id="200"
+ reporter="[null]"
+ issue_attributes="JIRA=http://jira.com"
+ action_plan_key="[null]"
+ tags="tag1,tag2,tag3"
+ created_at="1400000000000"
+ updated_at="1400000000000"
+ issue_creation_date="1115848800000"
+ issue_update_date="1356994800000"
+ issue_close_date="[null]"
+ locations="[null]"
+ issue_type="1"/>
+
+ <issues
+ id="2"
+ kee="DEF"
+ resolution="[null]"
+ status="OPEN"
+ severity="MAJOR"
+ manual_severity="[false]"
+ assignee="guy2"
+ author_login="[null]"
+ checksum="FFFFF"
+ gap="[null]"
+ effort="15"
+ message="[null]"
+ line="444"
+ component_uuid="ROOT_FILE"
+ project_uuid="PROJECT"
+ rule_id="200"
+ reporter="[null]"
+ issue_attributes="JIRA=http://jira.com"
+ action_plan_key="[null]"
+ tags="[null]"
+ created_at="1400000000000"
+ updated_at="1450000000000"
+ issue_creation_date="1115848800000"
+ issue_update_date="1368828000000"
+ issue_close_date="[null]"
+ locations="[null]"
+ issue_type="1"/>
+
+ <issues
+ id="3"
+ kee="EFG"
+ resolution="[null]"
+ status="OPEN"
+ severity="MAJOR"
+ manual_severity="[false]"
+ assignee="guy2"
+ author_login="[null]"
+ checksum="FFFFF"
+ gap="[null]"
+ effort="15"
+ message="[null]"
+ line="[null]"
+ component_uuid="PROJECT"
+ project_uuid="PROJECT"
+ rule_id="200"
+ reporter="[null]"
+ issue_attributes="JIRA=http://jira.com"
+ action_plan_key="[null]"
+ tags="[null]"
+ created_at="1400000000000"
+ updated_at="1450000000000"
+ issue_creation_date="1115848800000"
+ issue_update_date="1368828000000"
+ issue_close_date="[null]"
+ locations="[null]"
+ issue_type="1"/>
+
+ <issues
+ id="4"
+ kee="FGH"
+ resolution="[null]"
+ status="OPEN"
+ severity="MAJOR"
+ manual_severity="[false]"
+ assignee="guy2"
+ author_login="[null]"
+ checksum="FFFFF"
+ gap="[null]"
+ effort="15"
+ message="[null]"
+ line="[null]"
+ component_uuid="MODULE"
+ project_uuid="PROJECT"
+ rule_id="200"
+ reporter="[null]"
+ issue_attributes="JIRA=http://jira.com"
+ action_plan_key="[null]"
+ tags="[null]"
+ created_at="1400000000000"
+ updated_at="1450000000000"
+ issue_creation_date="1115848800000"
+ issue_update_date="1368828000000"
+ issue_close_date="[null]"
+ locations="[null]"
+ issue_type="1"/>
+
+</dataset>
--- /dev/null
+<dataset>
+ <rules system_tags="[null]"
+ id="200"
+ name="Avoid Cycles"
+ plugin_rule_key="AvoidCycles"
+ plugin_config_key="[null]"
+ plugin_name="squid"/>
+
+ <projects organization_uuid="org1"
+ uuid="PROJECT"
+ uuid_path="NOT_USED"
+ root_uuid="MODULE"
+ project_uuid="MODULE"
+ path="[null]"
+ module_uuid_path=".PROJECT."
+ id="10"
+ scope="PRJ"
+ qualifier="TRK"
+ kee="struts"
+ name="Struts"
+ private="[false]"/>
+ <projects organization_uuid="org1"
+ uuid="MODULE"
+ uuid_path="NOT_USED"
+ root_uuid="PROJECT"
+ project_uuid="PROJECT"
+ path="struts-core"
+ module_uuid_path=".PROJECT.MODULE."
+ id="11"
+ scope="PRJ"
+ qualifier="BRC"
+ kee="struts-core"
+ name="Struts Core"
+ private="[false]"/>
+ <projects organization_uuid="org1"
+ uuid="FILE"
+ uuid_path="NOT_USED"
+ root_uuid="MODULE"
+ project_uuid="MODULE"
+ path="src/main/java/Action.java"
+ module_uuid_path=".PROJECT.MODULE."
+ id="100"
+ scope="FIL"
+ qualifier="FIL"
+ kee="struts:Action"
+ name="Action"
+ private="[false]"/>
+ <projects organization_uuid="org1"
+ uuid="ROOT_FILE"
+ uuid_path="NOT_USED"
+ root_uuid="MODULE"
+ project_uuid="MODULE"
+ path="pom.xml"
+ module_uuid_path=".PROJECT.MODULE."
+ id="101"
+ scope="FIL"
+ qualifier="FIL"
+ kee="pom"
+ name="pom.xml"
+ private="[false]"/>
+
+ <issues
+ id="1"
+ kee="ABC"
+ resolution="FIXED"
+ status="RESOLVED"
+ severity="BLOCKER"
+ manual_severity="[false]"
+ assignee="guy1"
+ author_login="guy2"
+ checksum="FFFFF"
+ gap="[null]"
+ effort="10"
+ message="[null]"
+ line="444"
+ component_uuid="FILE"
+ project_uuid="PROJECT"
+ rule_id="200"
+ reporter="[null]"
+ issue_attributes="JIRA=http://jira.com"
+ action_plan_key="PLAN1"
+ tags="tag1,tag2,tag3"
+ created_at="1400000000000"
+ updated_at="1400000000000"
+ issue_creation_date="1115848800000"
+ issue_update_date="1356994800000"
+ issue_close_date="[null]"
+ locations="[null]"
+ issue_type="1"/>
+
+ <issues
+ id="2"
+ kee="DEF"
+ resolution="[null]"
+ status="OPEN"
+ severity="MAJOR"
+ manual_severity="[false]"
+ assignee="guy2"
+ author_login="[null]"
+ checksum="FFFFF"
+ gap="[null]"
+ effort="15"
+ message="[null]"
+ line="444"
+ component_uuid="ROOT_FILE"
+ project_uuid="PROJECT"
+ rule_id="200"
+ reporter="[null]"
+ issue_attributes="JIRA=http://jira.com"
+ action_plan_key="PLAN2"
+ tags="[null]"
+ created_at="1400000000000"
+ updated_at="1450000000000"
+ issue_creation_date="1115848800000"
+ issue_update_date="1368828000000"
+ issue_close_date="[null]"
+ locations="[null]"
+ issue_type="1"/>
+
+ <issues
+ id="3"
+ kee="EFG"
+ resolution="[null]"
+ status="OPEN"
+ severity="MAJOR"
+ manual_severity="[false]"
+ assignee="guy2"
+ author_login="[null]"
+ checksum="FFFFF"
+ gap="[null]"
+ effort="15"
+ message="[null]"
+ line="[null]"
+ component_uuid="PROJECT"
+ project_uuid="PROJECT"
+ rule_id="200"
+ reporter="[null]"
+ issue_attributes="JIRA=http://jira.com"
+ action_plan_key="PLAN2"
+ tags="[null]"
+ created_at="1400000000000"
+ updated_at="1450000000000"
+ issue_creation_date="1115848800000"
+ issue_update_date="1368828000000"
+ issue_close_date="[null]"
+ locations="[null]"
+ issue_type="1"/>
+
+ <issues
+ id="4"
+ kee="FGH"
+ resolution="[null]"
+ status="OPEN"
+ severity="MAJOR"
+ manual_severity="[false]"
+ assignee="guy2"
+ author_login="[null]"
+ checksum="FFFFF"
+ gap="[null]"
+ effort="15"
+ message="[null]"
+ line="[null]"
+ component_uuid="MODULE"
+ project_uuid="PROJECT"
+ rule_id="200"
+ reporter="[null]"
+ issue_attributes="JIRA=http://jira.com"
+ action_plan_key="PLAN2"
+ tags="[null]"
+ created_at="1400000000000"
+ updated_at="1450000000000"
+ issue_creation_date="1115848800000"
+ issue_update_date="1368828000000"
+ issue_close_date="[null]"
+ locations="[null]"
+ issue_type="1"/>
+
+</dataset>
--- /dev/null
+<dataset>
+ <rules id="1"
+ system_tags="[null]"
+ name="Avoid Cycles"
+ plugin_rule_key="AvoidCycles"
+ plugin_config_key="[null]"
+ plugin_name="squid"/>
+
+ <!-- Project 1 -->
+ <projects organization_uuid="org1"
+ uuid="THE_PROJECT_1"
+ uuid_path="NOT_USED"
+ root_uuid="THE_PROJECT_1"
+ project_uuid="THE_PROJECT_1"
+ module_uuid="[null]"
+ module_uuid_path="."
+ path="[null]"
+ id="10"
+ scope="PRJ"
+ qualifier="TRK"
+ kee="the_project_1"
+ name="TheProject1"
+ private="[false]"/>
+ <projects organization_uuid="org1"
+ uuid="THE_FILE_1"
+ uuid_path="NOT_USED"
+ root_uuid="THE_PROJECT_1"
+ project_uuid="THE_PROJECT_1"
+ module_uuid="THE_PROJECT_1"
+ module_uuid_path=".THE_PROJECT_1."
+ path="src/main/java/TheFile.java"
+ id="11"
+ scope="FIL"
+ qualifier="FIL"
+ kee="the_file_1"
+ name="TheFile1"
+ private="[false]"/>
+
+ <issues
+ id="1"
+ kee="ABCDE"
+ resolution="FIXED"
+ status="RESOLVED"
+ severity="BLOCKER"
+ manual_severity="[false]"
+ assignee="winner"
+ author_login="[null]"
+ checksum="FFFFF"
+ gap="[null]"
+ effort="[null]"
+ message="[null]"
+ line="444"
+ component_uuid="THE_FILE_1"
+ project_uuid="THE_PROJECT_1"
+ rule_id="1"
+ reporter="[null]"
+ issue_attributes="JIRA=http://jira.com"
+ action_plan_key="[null]"
+ created_at="1500000000000"
+ updated_at="1550000000000"
+ issue_creation_date="1115848800000"
+ issue_update_date="1368828000000"
+ issue_close_date="[null]"
+ locations="[null]"
+ issue_type="1"
+ />
+
+ <issues id="2"
+ kee="BCDEF"
+ resolution="FIXED"
+ status="RESOLVED"
+ severity="BLOCKER"
+ manual_severity="[false]"
+ assignee="winner"
+ author_login="[null]"
+ checksum="FFFFF"
+ gap="[null]"
+ effort="[null]"
+ message="[null]"
+ line="444"
+ component_uuid="THE_FILE_1"
+ project_uuid="THE_PROJECT_1"
+ rule_id="1"
+ reporter="[null]"
+ issue_attributes="JIRA=http://jira.com"
+ action_plan_key="[null]"
+ created_at="2000000000000"
+ updated_at="2550000000000"
+ issue_creation_date="2115848800000"
+ issue_update_date="2368828000000"
+ issue_close_date="[null]"
+ locations="[null]"
+ issue_type="1"
+ />
+
+ <!-- Project 2 -->
+ <projects organization_uuid="org1"
+ uuid="THE_PROJECT_2"
+ uuid_path="NOT_USED"
+ root_uuid="THE_PROJECT_2"
+ project_uuid="THE_PROJECT_2"
+ module_uuid="[null]"
+ module_uuid_path="."
+ path="[null]"
+ id="100"
+ scope="PRJ"
+ qualifier="TRK"
+ kee="the_project_2"
+ name="TheProject2"
+ private="[false]"/>
+ <projects organization_uuid="org1"
+ uuid="THE_FILE_2"
+ uuid_path="NOT_USED"
+ root_uuid="THE_PROJECT_2"
+ project_uuid="THE_PROJECT_2"
+ module_uuid="THE_PROJECT_2"
+ module_uuid_path=".THE_PROJECT_2."
+ path="src/main/java/TheFile.java"
+ id="111"
+ scope="FIL"
+ qualifier="FIL"
+ kee="the_file_2"
+ name="TheFile2"
+ private="[false]"/>
+
+ <issues id="10"
+ kee="EDCBA"
+ resolution="FIXED"
+ status="RESOLVED"
+ severity="BLOCKER"
+ manual_severity="[false]"
+ assignee="winner"
+ author_login="[null]"
+ checksum="FFFFF"
+ gap="[null]"
+ effort="[null]"
+ message="[null]"
+ line="444"
+ component_uuid="THE_FILE_2"
+ project_uuid="THE_PROJECT_2"
+ rule_id="1"
+ reporter="[null]"
+ issue_attributes="JIRA=http://jira.com"
+ action_plan_key="[null]"
+ created_at="1500000000000"
+ updated_at="1550000000000"
+ issue_creation_date="1115848800000"
+ issue_update_date="1368828000000"
+ issue_close_date="[null]"
+ locations="[null]"
+ issue_type="1"
+ />
+</dataset>
--- /dev/null
+<dataset>
+ <rules system_tags="[null]"
+ id="200"
+ name="Avoid Cycles"
+ plugin_rule_key="AvoidCycles"
+ plugin_config_key="[null]"
+ plugin_name="squid"/>
+
+ <projects organization_uuid="org1"
+ uuid="PROJECT1"
+ uuid_path="NOT_USED"
+ root_uuid="PROJECT1"
+ project_uuid="PROJECT1"
+ path="[null]"
+ module_uuid_path=".PROJECT1."
+ id="10"
+ scope="PRJ"
+ qualifier="TRK"
+ kee="struts"
+ name="Struts"
+ private="[false]"/>
+ <projects organization_uuid="org1"
+ uuid="MODULE1"
+ uuid_path="NOT_USED"
+ root_uuid="PROJECT1"
+ project_uuid="PROJECT1"
+ path="[null]"
+ module_uuid_path=".PROJECT1.MODULE1."
+ id="50"
+ scope="PRJ"
+ qualifier="BRC"
+ kee="struts:struts-tiles"
+ name="Struts Tiles"
+ private="[false]"/>
+ <projects organization_uuid="org1"
+ uuid="DIR1"
+ uuid_path="NOT_USED"
+ root_uuid="MODULE1"
+ project_uuid="MODULE1"
+ path="src/main/java"
+ module_uuid_path=".PROJECT1.MODULE1."
+ id="70"
+ scope="DIR"
+ qualifier="DIR"
+ kee="struts:struts-tiles:/"
+ name="src/main/java/"
+ private="[false]"/>
+ <projects organization_uuid="org1"
+ uuid="FILE1"
+ uuid_path="NOT_USED"
+ root_uuid="MODULE1"
+ project_uuid="MODULE1"
+ path="src/main/java/Action.java"
+ module_uuid_path=".PROJECT1."
+ id="100"
+ scope="FIL"
+ qualifier="CLA"
+ kee="struts:Action"
+ name="Action"
+ private="[false]"/>
+
+ <issues
+ id="1"
+ kee="ABC"
+ resolution="FIXED"
+ status="RESOLVED"
+ severity="BLOCKER"
+ manual_severity="[false]"
+ assignee="guy1"
+ author_login="guy2"
+ checksum="FFFFF"
+ gap="2"
+ effort="10"
+ message="[null]"
+ line="444"
+ component_uuid="FILE1"
+ project_uuid="PROJECT1"
+ rule_id="200"
+ reporter="[null]"
+ issue_attributes="JIRA=http://jira.com"
+ action_plan_key="PLAN1"
+ tags="tag1,tag2,tag3"
+ created_at="1400000000000"
+ updated_at="1400000000000"
+ issue_creation_date="1115848800000"
+ issue_update_date="1356994800000"
+ issue_close_date="[null]"
+ locations="[null]"
+ issue_type="2"
+ />
+
+</dataset>
--- /dev/null
+<dataset>
+ <rules system_tags="[null]"
+ id="200"
+ name="Avoid Cycles"
+ plugin_rule_key="AvoidCycles"
+ plugin_config_key="[null]"
+ plugin_name="squid"/>
+
+ <projects organization_uuid="org1"
+ uuid="PROJECT1"
+ uuid_path="NOT_USED"
+ root_uuid="PROJECT1"
+ project_uuid="PROJECT1"
+ path="[null]"
+ module_uuid_path=".PROJECT1."
+ id="10"
+ scope="PRJ"
+ qualifier="TRK"
+ kee="struts"
+ name="Struts"
+ private="[false]"/>
+ <projects organization_uuid="org1"
+ uuid="MODULE1"
+ uuid_path="NOT_USED"
+ root_uuid="PROJECT1"
+ project_uuid="PROJECT1"
+ path="[null]"
+ module_uuid_path=".PROJECT1.MODULE1."
+ id="50"
+ scope="PRJ"
+ qualifier="BRC"
+ kee="struts:struts-tiles"
+ name="Struts Tiles"
+ private="[false]"/>
+ <projects organization_uuid="org1"
+ uuid="DIR1"
+ uuid_path="NOT_USED"
+ root_uuid="MODULE1"
+ project_uuid="MODULE1"
+ path="src/main/java"
+ module_uuid_path=".PROJECT1.MODULE1."
+ id="70"
+ scope="DIR"
+ qualifier="DIR"
+ kee="struts:struts-tiles:/"
+ name="src/main/java/"
+ private="[false]"/>
+ <projects organization_uuid="org1"
+ uuid="FILE1"
+ uuid_path="NOT_USED"
+ root_uuid="MODULE1"
+ project_uuid="MODULE1"
+ path="src/main/java/Action.java"
+ module_uuid_path=".PROJECT1."
+ id="100"
+ scope="FIL"
+ qualifier="CLA"
+ kee="struts:Action"
+ name="Action"
+ private="[false]"/>
+
+ <issues
+ id="1"
+ kee="ABC"
+ resolution="FIXED"
+ status="RESOLVED"
+ severity="BLOCKER"
+ manual_severity="[false]"
+ assignee="guy1"
+ author_login="guy2"
+ checksum="FFFFF"
+ gap="[null]"
+ effort="10"
+ message="[null]"
+ line="444"
+ component_uuid="FILE1"
+ project_uuid="PROJECT1"
+ rule_id="200"
+ reporter="[null]"
+ issue_attributes="JIRA=http://jira.com"
+ action_plan_key="[null]"
+ tags="tag1,tag2,tag3"
+ created_at="1400000000000"
+ updated_at="1400000000000"
+ issue_creation_date="1115848800000"
+ issue_update_date="1356994800000"
+ issue_close_date="[null]"
+ locations="[null]"
+ issue_type="1"
+ />
+
+ <issues
+ id="2"
+ kee="BCD"
+ resolution="FIXED"
+ status="RESOLVED"
+ severity="BLOCKER"
+ manual_severity="[false]"
+ assignee="guy1"
+ author_login="guy2"
+ checksum="FFFFF"
+ gap="[null]"
+ effort="10"
+ message="[null]"
+ line="444"
+ component_uuid="MODULE1"
+ project_uuid="PROJECT1"
+ rule_id="200"
+ reporter="[null]"
+ issue_attributes="JIRA=http://jira.com"
+ action_plan_key="[null]"
+ tags="tag1,tag2,tag3"
+ created_at="1400000000000"
+ updated_at="1400000000000"
+ issue_creation_date="1115848800000"
+ issue_update_date="1356994800000"
+ issue_close_date="[null]"
+ locations="[null]"
+ issue_type="2"
+ />
+
+ <issues
+ id="3"
+ kee="DEF"
+ resolution="[null]"
+ status="OPEN"
+ severity="MAJOR"
+ manual_severity="[false]"
+ assignee="guy2"
+ author_login="[null]"
+ checksum="FFFFF"
+ gap="[null]"
+ effort="15"
+ message="[null]"
+ line="444"
+ component_uuid="FILE1"
+ project_uuid="PROJECT1"
+ rule_id="200"
+ reporter="[null]"
+ issue_attributes="JIRA=http://jira.com"
+ action_plan_key="[null]"
+ tags="[null]"
+ created_at="1400000000000"
+ updated_at="1450000000000"
+ issue_creation_date="1115848800000"
+ issue_update_date="1368828000000"
+ issue_close_date="[null]"
+ locations="[null]"
+ issue_type="1"
+ />
+
+ <issues
+ id="4"
+ kee="EFG"
+ resolution="FIXED"
+ status="RESOLVED"
+ severity="BLOCKER"
+ manual_severity="[false]"
+ assignee="guy1"
+ author_login="guy2"
+ checksum="FFFFF"
+ gap="[null]"
+ effort="10"
+ message="[null]"
+ line="444"
+ component_uuid="DIR1"
+ project_uuid="PROJECT1"
+ rule_id="200"
+ reporter="[null]"
+ issue_attributes="JIRA=http://jira.com"
+ action_plan_key="[null]"
+ tags="[null]"
+ created_at="1400000000000"
+ updated_at="1400000000000"
+ issue_creation_date="1115848800000"
+ issue_update_date="1356994800000"
+ issue_close_date="[null]"
+ locations="[null]"
+ issue_type="1"
+ />
+
+</dataset>
+++ /dev/null
-<dataset>
- <rules system_tags="[null]"
- id="200"
- name="Avoid Cycles"
- plugin_rule_key="AvoidCycles"
- plugin_config_key="[null]"
- plugin_name="squid"/>
-
- <projects organization_uuid="org1"
- uuid="PROJECT"
- uuid_path="NOT_USED"
- root_uuid="MODULE"
- project_uuid="MODULE"
- path="[null]"
- module_uuid_path=".PROJECT."
- id="10"
- scope="PRJ"
- qualifier="TRK"
- kee="struts"
- name="Struts"
- private="[false]"/>
- <projects organization_uuid="org1"
- uuid="MODULE"
- uuid_path="NOT_USED"
- root_uuid="PROJECT"
- project_uuid="PROJECT"
- path="struts-core"
- module_uuid_path=".PROJECT.MODULE."
- id="11"
- scope="PRJ"
- qualifier="BRC"
- kee="struts-core"
- name="Struts Core"
- private="[false]"/>
- <projects organization_uuid="org1"
- uuid="FILE"
- uuid_path="NOT_USED"
- root_uuid="MODULE"
- project_uuid="MODULE"
- path="src/main/java/Action.java"
- module_uuid_path=".PROJECT.MODULE."
- id="100"
- scope="FIL"
- qualifier="FIL"
- kee="struts:Action"
- name="Action"
- private="[false]"/>
- <projects organization_uuid="org1"
- uuid="ROOT_FILE"
- uuid_path="NOT_USED"
- root_uuid="MODULE"
- project_uuid="MODULE"
- path="pom.xml"
- module_uuid_path=".PROJECT.MODULE."
- id="101"
- scope="FIL"
- qualifier="FIL"
- kee="pom"
- name="pom.xml"
- private="[false]"/>
-
- <issues id="1"
- kee="ABC"
- resolution="FIXED"
- status="RESOLVED"
- severity="BLOCKER"
- manual_severity="[false]"
- assignee="guy1"
- author_login="guy2"
- checksum="FFFFF"
- gap="[null]"
- effort="10"
- message="[null]"
- line="444"
- component_uuid="FILE"
- project_uuid="PROJECT"
- rule_id="200"
- reporter="[null]"
- issue_attributes="JIRA=http://jira.com"
- action_plan_key="[null]"
- tags="tag1,tag2,tag3"
- created_at="1400000000000"
- updated_at="1400000000000"
- issue_creation_date="1115848800000"
- issue_update_date="1356994800000"
- issue_close_date="[null]"
- locations="[null]"
- issue_type="1"/>
-
- <issues
- id="2"
- kee="DEF"
- resolution="[null]"
- status="OPEN"
- severity="MAJOR"
- manual_severity="[false]"
- assignee="guy2"
- author_login="[null]"
- checksum="FFFFF"
- gap="[null]"
- effort="15"
- message="[null]"
- line="444"
- component_uuid="ROOT_FILE"
- project_uuid="PROJECT"
- rule_id="200"
- reporter="[null]"
- issue_attributes="JIRA=http://jira.com"
- action_plan_key="[null]"
- tags="[null]"
- created_at="1400000000000"
- updated_at="1450000000000"
- issue_creation_date="1115848800000"
- issue_update_date="1368828000000"
- issue_close_date="[null]"
- locations="[null]"
- issue_type="1"/>
-
- <issues
- id="3"
- kee="EFG"
- resolution="[null]"
- status="OPEN"
- severity="MAJOR"
- manual_severity="[false]"
- assignee="guy2"
- author_login="[null]"
- checksum="FFFFF"
- gap="[null]"
- effort="15"
- message="[null]"
- line="[null]"
- component_uuid="PROJECT"
- project_uuid="PROJECT"
- rule_id="200"
- reporter="[null]"
- issue_attributes="JIRA=http://jira.com"
- action_plan_key="[null]"
- tags="[null]"
- created_at="1400000000000"
- updated_at="1450000000000"
- issue_creation_date="1115848800000"
- issue_update_date="1368828000000"
- issue_close_date="[null]"
- locations="[null]"
- issue_type="1"/>
-
- <issues
- id="4"
- kee="FGH"
- resolution="[null]"
- status="OPEN"
- severity="MAJOR"
- manual_severity="[false]"
- assignee="guy2"
- author_login="[null]"
- checksum="FFFFF"
- gap="[null]"
- effort="15"
- message="[null]"
- line="[null]"
- component_uuid="MODULE"
- project_uuid="PROJECT"
- rule_id="200"
- reporter="[null]"
- issue_attributes="JIRA=http://jira.com"
- action_plan_key="[null]"
- tags="[null]"
- created_at="1400000000000"
- updated_at="1450000000000"
- issue_creation_date="1115848800000"
- issue_update_date="1368828000000"
- issue_close_date="[null]"
- locations="[null]"
- issue_type="1"/>
-
-</dataset>
+++ /dev/null
-<dataset>
- <rules system_tags="[null]"
- id="200"
- name="Avoid Cycles"
- plugin_rule_key="AvoidCycles"
- plugin_config_key="[null]"
- plugin_name="squid"/>
-
- <projects organization_uuid="org1"
- uuid="PROJECT"
- uuid_path="NOT_USED"
- root_uuid="MODULE"
- project_uuid="MODULE"
- path="[null]"
- module_uuid_path=".PROJECT."
- id="10"
- scope="PRJ"
- qualifier="TRK"
- kee="struts"
- name="Struts"
- private="[false]"/>
- <projects organization_uuid="org1"
- uuid="MODULE"
- uuid_path="NOT_USED"
- root_uuid="PROJECT"
- project_uuid="PROJECT"
- path="struts-core"
- module_uuid_path=".PROJECT.MODULE."
- id="11"
- scope="PRJ"
- qualifier="BRC"
- kee="struts-core"
- name="Struts Core"
- private="[false]"/>
- <projects organization_uuid="org1"
- uuid="FILE"
- uuid_path="NOT_USED"
- root_uuid="MODULE"
- project_uuid="MODULE"
- path="src/main/java/Action.java"
- module_uuid_path=".PROJECT.MODULE."
- id="100"
- scope="FIL"
- qualifier="FIL"
- kee="struts:Action"
- name="Action"
- private="[false]"/>
- <projects organization_uuid="org1"
- uuid="ROOT_FILE"
- uuid_path="NOT_USED"
- root_uuid="MODULE"
- project_uuid="MODULE"
- path="pom.xml"
- module_uuid_path=".PROJECT.MODULE."
- id="101"
- scope="FIL"
- qualifier="FIL"
- kee="pom"
- name="pom.xml"
- private="[false]"/>
-
- <issues
- id="1"
- kee="ABC"
- resolution="FIXED"
- status="RESOLVED"
- severity="BLOCKER"
- manual_severity="[false]"
- assignee="guy1"
- author_login="guy2"
- checksum="FFFFF"
- gap="[null]"
- effort="10"
- message="[null]"
- line="444"
- component_uuid="FILE"
- project_uuid="PROJECT"
- rule_id="200"
- reporter="[null]"
- issue_attributes="JIRA=http://jira.com"
- action_plan_key="PLAN1"
- tags="tag1,tag2,tag3"
- created_at="1400000000000"
- updated_at="1400000000000"
- issue_creation_date="1115848800000"
- issue_update_date="1356994800000"
- issue_close_date="[null]"
- locations="[null]"
- issue_type="1"/>
-
- <issues
- id="2"
- kee="DEF"
- resolution="[null]"
- status="OPEN"
- severity="MAJOR"
- manual_severity="[false]"
- assignee="guy2"
- author_login="[null]"
- checksum="FFFFF"
- gap="[null]"
- effort="15"
- message="[null]"
- line="444"
- component_uuid="ROOT_FILE"
- project_uuid="PROJECT"
- rule_id="200"
- reporter="[null]"
- issue_attributes="JIRA=http://jira.com"
- action_plan_key="PLAN2"
- tags="[null]"
- created_at="1400000000000"
- updated_at="1450000000000"
- issue_creation_date="1115848800000"
- issue_update_date="1368828000000"
- issue_close_date="[null]"
- locations="[null]"
- issue_type="1"/>
-
- <issues
- id="3"
- kee="EFG"
- resolution="[null]"
- status="OPEN"
- severity="MAJOR"
- manual_severity="[false]"
- assignee="guy2"
- author_login="[null]"
- checksum="FFFFF"
- gap="[null]"
- effort="15"
- message="[null]"
- line="[null]"
- component_uuid="PROJECT"
- project_uuid="PROJECT"
- rule_id="200"
- reporter="[null]"
- issue_attributes="JIRA=http://jira.com"
- action_plan_key="PLAN2"
- tags="[null]"
- created_at="1400000000000"
- updated_at="1450000000000"
- issue_creation_date="1115848800000"
- issue_update_date="1368828000000"
- issue_close_date="[null]"
- locations="[null]"
- issue_type="1"/>
-
- <issues
- id="4"
- kee="FGH"
- resolution="[null]"
- status="OPEN"
- severity="MAJOR"
- manual_severity="[false]"
- assignee="guy2"
- author_login="[null]"
- checksum="FFFFF"
- gap="[null]"
- effort="15"
- message="[null]"
- line="[null]"
- component_uuid="MODULE"
- project_uuid="PROJECT"
- rule_id="200"
- reporter="[null]"
- issue_attributes="JIRA=http://jira.com"
- action_plan_key="PLAN2"
- tags="[null]"
- created_at="1400000000000"
- updated_at="1450000000000"
- issue_creation_date="1115848800000"
- issue_update_date="1368828000000"
- issue_close_date="[null]"
- locations="[null]"
- issue_type="1"/>
-
-</dataset>
+++ /dev/null
-<dataset>
- <rules id="1"
- system_tags="[null]"
- name="Avoid Cycles"
- plugin_rule_key="AvoidCycles"
- plugin_config_key="[null]"
- plugin_name="squid"/>
-
- <!-- Project 1 -->
- <projects organization_uuid="org1"
- uuid="THE_PROJECT_1"
- uuid_path="NOT_USED"
- root_uuid="THE_PROJECT_1"
- project_uuid="THE_PROJECT_1"
- module_uuid="[null]"
- module_uuid_path="."
- path="[null]"
- id="10"
- scope="PRJ"
- qualifier="TRK"
- kee="the_project_1"
- name="TheProject1"
- private="[false]"/>
- <projects organization_uuid="org1"
- uuid="THE_FILE_1"
- uuid_path="NOT_USED"
- root_uuid="THE_PROJECT_1"
- project_uuid="THE_PROJECT_1"
- module_uuid="THE_PROJECT_1"
- module_uuid_path=".THE_PROJECT_1."
- path="src/main/java/TheFile.java"
- id="11"
- scope="FIL"
- qualifier="FIL"
- kee="the_file_1"
- name="TheFile1"
- private="[false]"/>
-
- <issues
- id="1"
- kee="ABCDE"
- resolution="FIXED"
- status="RESOLVED"
- severity="BLOCKER"
- manual_severity="[false]"
- assignee="winner"
- author_login="[null]"
- checksum="FFFFF"
- gap="[null]"
- effort="[null]"
- message="[null]"
- line="444"
- component_uuid="THE_FILE_1"
- project_uuid="THE_PROJECT_1"
- rule_id="1"
- reporter="[null]"
- issue_attributes="JIRA=http://jira.com"
- action_plan_key="[null]"
- created_at="1500000000000"
- updated_at="1550000000000"
- issue_creation_date="1115848800000"
- issue_update_date="1368828000000"
- issue_close_date="[null]"
- locations="[null]"
- issue_type="1"
- />
-
- <issues id="2"
- kee="BCDEF"
- resolution="FIXED"
- status="RESOLVED"
- severity="BLOCKER"
- manual_severity="[false]"
- assignee="winner"
- author_login="[null]"
- checksum="FFFFF"
- gap="[null]"
- effort="[null]"
- message="[null]"
- line="444"
- component_uuid="THE_FILE_1"
- project_uuid="THE_PROJECT_1"
- rule_id="1"
- reporter="[null]"
- issue_attributes="JIRA=http://jira.com"
- action_plan_key="[null]"
- created_at="2000000000000"
- updated_at="2550000000000"
- issue_creation_date="2115848800000"
- issue_update_date="2368828000000"
- issue_close_date="[null]"
- locations="[null]"
- issue_type="1"
- />
-
- <!-- Project 2 -->
- <projects organization_uuid="org1"
- uuid="THE_PROJECT_2"
- uuid_path="NOT_USED"
- root_uuid="THE_PROJECT_2"
- project_uuid="THE_PROJECT_2"
- module_uuid="[null]"
- module_uuid_path="."
- path="[null]"
- id="100"
- scope="PRJ"
- qualifier="TRK"
- kee="the_project_2"
- name="TheProject2"
- private="[false]"/>
- <projects organization_uuid="org1"
- uuid="THE_FILE_2"
- uuid_path="NOT_USED"
- root_uuid="THE_PROJECT_2"
- project_uuid="THE_PROJECT_2"
- module_uuid="THE_PROJECT_2"
- module_uuid_path=".THE_PROJECT_2."
- path="src/main/java/TheFile.java"
- id="111"
- scope="FIL"
- qualifier="FIL"
- kee="the_file_2"
- name="TheFile2"
- private="[false]"/>
-
- <issues id="10"
- kee="EDCBA"
- resolution="FIXED"
- status="RESOLVED"
- severity="BLOCKER"
- manual_severity="[false]"
- assignee="winner"
- author_login="[null]"
- checksum="FFFFF"
- gap="[null]"
- effort="[null]"
- message="[null]"
- line="444"
- component_uuid="THE_FILE_2"
- project_uuid="THE_PROJECT_2"
- rule_id="1"
- reporter="[null]"
- issue_attributes="JIRA=http://jira.com"
- action_plan_key="[null]"
- created_at="1500000000000"
- updated_at="1550000000000"
- issue_creation_date="1115848800000"
- issue_update_date="1368828000000"
- issue_close_date="[null]"
- locations="[null]"
- issue_type="1"
- />
-</dataset>
+++ /dev/null
-<dataset>
- <rules system_tags="[null]"
- id="200"
- name="Avoid Cycles"
- plugin_rule_key="AvoidCycles"
- plugin_config_key="[null]"
- plugin_name="squid"/>
-
- <projects organization_uuid="org1"
- uuid="PROJECT1"
- uuid_path="NOT_USED"
- root_uuid="PROJECT1"
- project_uuid="PROJECT1"
- path="[null]"
- module_uuid_path=".PROJECT1."
- id="10"
- scope="PRJ"
- qualifier="TRK"
- kee="struts"
- name="Struts"
- private="[false]"/>
- <projects organization_uuid="org1"
- uuid="MODULE1"
- uuid_path="NOT_USED"
- root_uuid="PROJECT1"
- project_uuid="PROJECT1"
- path="[null]"
- module_uuid_path=".PROJECT1.MODULE1."
- id="50"
- scope="PRJ"
- qualifier="BRC"
- kee="struts:struts-tiles"
- name="Struts Tiles"
- private="[false]"/>
- <projects organization_uuid="org1"
- uuid="DIR1"
- uuid_path="NOT_USED"
- root_uuid="MODULE1"
- project_uuid="MODULE1"
- path="src/main/java"
- module_uuid_path=".PROJECT1.MODULE1."
- id="70"
- scope="DIR"
- qualifier="DIR"
- kee="struts:struts-tiles:/"
- name="src/main/java/"
- private="[false]"/>
- <projects organization_uuid="org1"
- uuid="FILE1"
- uuid_path="NOT_USED"
- root_uuid="MODULE1"
- project_uuid="MODULE1"
- path="src/main/java/Action.java"
- module_uuid_path=".PROJECT1."
- id="100"
- scope="FIL"
- qualifier="CLA"
- kee="struts:Action"
- name="Action"
- private="[false]"/>
-
- <issues
- id="1"
- kee="ABC"
- resolution="FIXED"
- status="RESOLVED"
- severity="BLOCKER"
- manual_severity="[false]"
- assignee="guy1"
- author_login="guy2"
- checksum="FFFFF"
- gap="2"
- effort="10"
- message="[null]"
- line="444"
- component_uuid="FILE1"
- project_uuid="PROJECT1"
- rule_id="200"
- reporter="[null]"
- issue_attributes="JIRA=http://jira.com"
- action_plan_key="PLAN1"
- tags="tag1,tag2,tag3"
- created_at="1400000000000"
- updated_at="1400000000000"
- issue_creation_date="1115848800000"
- issue_update_date="1356994800000"
- issue_close_date="[null]"
- locations="[null]"
- issue_type="2"
- />
-
-</dataset>
+++ /dev/null
-<dataset>
- <rules system_tags="[null]"
- id="200"
- name="Avoid Cycles"
- plugin_rule_key="AvoidCycles"
- plugin_config_key="[null]"
- plugin_name="squid"/>
-
- <projects organization_uuid="org1"
- uuid="PROJECT1"
- uuid_path="NOT_USED"
- root_uuid="PROJECT1"
- project_uuid="PROJECT1"
- path="[null]"
- module_uuid_path=".PROJECT1."
- id="10"
- scope="PRJ"
- qualifier="TRK"
- kee="struts"
- name="Struts"
- private="[false]"/>
- <projects organization_uuid="org1"
- uuid="MODULE1"
- uuid_path="NOT_USED"
- root_uuid="PROJECT1"
- project_uuid="PROJECT1"
- path="[null]"
- module_uuid_path=".PROJECT1.MODULE1."
- id="50"
- scope="PRJ"
- qualifier="BRC"
- kee="struts:struts-tiles"
- name="Struts Tiles"
- private="[false]"/>
- <projects organization_uuid="org1"
- uuid="DIR1"
- uuid_path="NOT_USED"
- root_uuid="MODULE1"
- project_uuid="MODULE1"
- path="src/main/java"
- module_uuid_path=".PROJECT1.MODULE1."
- id="70"
- scope="DIR"
- qualifier="DIR"
- kee="struts:struts-tiles:/"
- name="src/main/java/"
- private="[false]"/>
- <projects organization_uuid="org1"
- uuid="FILE1"
- uuid_path="NOT_USED"
- root_uuid="MODULE1"
- project_uuid="MODULE1"
- path="src/main/java/Action.java"
- module_uuid_path=".PROJECT1."
- id="100"
- scope="FIL"
- qualifier="CLA"
- kee="struts:Action"
- name="Action"
- private="[false]"/>
-
- <issues
- id="1"
- kee="ABC"
- resolution="FIXED"
- status="RESOLVED"
- severity="BLOCKER"
- manual_severity="[false]"
- assignee="guy1"
- author_login="guy2"
- checksum="FFFFF"
- gap="[null]"
- effort="10"
- message="[null]"
- line="444"
- component_uuid="FILE1"
- project_uuid="PROJECT1"
- rule_id="200"
- reporter="[null]"
- issue_attributes="JIRA=http://jira.com"
- action_plan_key="[null]"
- tags="tag1,tag2,tag3"
- created_at="1400000000000"
- updated_at="1400000000000"
- issue_creation_date="1115848800000"
- issue_update_date="1356994800000"
- issue_close_date="[null]"
- locations="[null]"
- issue_type="1"
- />
-
- <issues
- id="2"
- kee="BCD"
- resolution="FIXED"
- status="RESOLVED"
- severity="BLOCKER"
- manual_severity="[false]"
- assignee="guy1"
- author_login="guy2"
- checksum="FFFFF"
- gap="[null]"
- effort="10"
- message="[null]"
- line="444"
- component_uuid="MODULE1"
- project_uuid="PROJECT1"
- rule_id="200"
- reporter="[null]"
- issue_attributes="JIRA=http://jira.com"
- action_plan_key="[null]"
- tags="tag1,tag2,tag3"
- created_at="1400000000000"
- updated_at="1400000000000"
- issue_creation_date="1115848800000"
- issue_update_date="1356994800000"
- issue_close_date="[null]"
- locations="[null]"
- issue_type="2"
- />
-
- <issues
- id="3"
- kee="DEF"
- resolution="[null]"
- status="OPEN"
- severity="MAJOR"
- manual_severity="[false]"
- assignee="guy2"
- author_login="[null]"
- checksum="FFFFF"
- gap="[null]"
- effort="15"
- message="[null]"
- line="444"
- component_uuid="FILE1"
- project_uuid="PROJECT1"
- rule_id="200"
- reporter="[null]"
- issue_attributes="JIRA=http://jira.com"
- action_plan_key="[null]"
- tags="[null]"
- created_at="1400000000000"
- updated_at="1450000000000"
- issue_creation_date="1115848800000"
- issue_update_date="1368828000000"
- issue_close_date="[null]"
- locations="[null]"
- issue_type="1"
- />
-
- <issues
- id="4"
- kee="EFG"
- resolution="FIXED"
- status="RESOLVED"
- severity="BLOCKER"
- manual_severity="[false]"
- assignee="guy1"
- author_login="guy2"
- checksum="FFFFF"
- gap="[null]"
- effort="10"
- message="[null]"
- line="444"
- component_uuid="DIR1"
- project_uuid="PROJECT1"
- rule_id="200"
- reporter="[null]"
- issue_attributes="JIRA=http://jira.com"
- action_plan_key="[null]"
- tags="[null]"
- created_at="1400000000000"
- updated_at="1400000000000"
- issue_creation_date="1115848800000"
- issue_update_date="1356994800000"
- issue_close_date="[null]"
- locations="[null]"
- issue_type="1"
- />
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules id="10"
- name="Null Pointer"
- plugin_name="xoo"
- plugin_rule_key="S001"
- plugin_config_key="S1"
- description_format="HTML"
- description="S001 desc"
- language="xoo"
- priority="4"
- status="READY"
- is_template="[false]"
- template_id="[null]"
- system_tags="cwe"
- created_at="1500000000000"
- updated_at="1600000000000"/>
-
- <rules_profiles id="100"
- name="Sonar Way"
- organization_uuid="org-123"
- kee="sonar-way"
- language="xoo"
- parent_kee="[null]"
- is_built_in="[false]"/>
-
- <active_rules id="1"
- profile_id="100"
- rule_id="10"
- failure_level="3"
- inheritance="[null]"
- created_at="1500000000000"
- updated_at="1600000000000"/>
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules id="10"
- name="Null Pointer"
- plugin_rule_key="S001"
- plugin_name="xoo"
- plugin_config_key="S1"
- description_format="HTML"
- description="S001 desc"
- language="xoo"
- priority="4"
- status="READY"
- is_template="[false]"
- template_id="[null]"
- system_tags="cwe"
- created_at="1500000000000"
- updated_at="1600000000000"/>
-
- <rules_profiles id="1"
- name="Parent"
- organization_uuid="org-123"
- kee="parent"
- language="xoo"
- parent_kee="[null]"
- is_built_in="[false]"
- />
-
- <rules_profiles id="2"
- name="Child"
- organization_uuid="org-123"
- kee="child"
- language="xoo"
- parent_kee="parent"
- is_built_in="[false]"
- />
-
- <active_rules id="1"
- profile_id="2"
- rule_id="10"
- failure_level="4"
- inheritance="INHERITED"
- created_at="1500000000000"
- updated_at="1600000000000"/>
-
- <!-- Parent of Active rule 1 -->
- <active_rules id="2"
- profile_id="1"
- rule_id="10"
- failure_level="0"
- inheritance="[null]"
- created_at="1500000000000"
- updated_at="1600000000000"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules id="10"
- name="Null Pointer"
- plugin_rule_key="S001"
- plugin_name="xoo"
- plugin_config_key="S1"
- description_format="HTML"
- description="S001 desc"
- language="xoo"
- priority="4"
- status="READY"
- is_template="[false]"
- template_id="[null]"
- system_tags="cwe"
- created_at="1500000000000"
- updated_at="1600000000000"/>
-
- <rules_profiles id="1"
- name="Parent"
- organization_uuid="org-123"
- kee="parent"
- language="xoo"
- parent_kee="[null]"
- is_built_in="[false]"
- />
-
- <rules_profiles id="2"
- name="Child"
- organization_uuid="org-123"
- kee="child"
- language="xoo"
- parent_kee="parent"
- is_built_in="[false]"
- />
-
- <active_rules id="1"
- profile_id="2"
- rule_id="10"
- failure_level="2"
- inheritance="OVERRIDES"
- created_at="1500000000000"
- updated_at="1600000000000"/>
-
- <!-- Parent of Active rule 1 -->
- <active_rules id="2"
- profile_id="1"
- rule_id="10"
- failure_level="0"
- inheritance="[null]"
- created_at="1500000000000"
- updated_at="1600000000000"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules id="10"
- name="Null Pointer"
- plugin_name="xoo"
- plugin_rule_key="S001"
- plugin_config_key="S1"
- description_format="HTML"
- description="S001 desc"
- language="xoo"
- priority="4"
- status="READY"
- is_template="[false]"
- template_id="[null]"
- system_tags="cwe"
- created_at="1500000000000"
- updated_at="1600000000000"/>
-
- <rules_profiles id="100"
- name="Sonar Way"
- organization_uuid="org-123"
- kee="sonar-way"
- language="xoo"
- parent_kee="[null]"
- is_built_in="[false]"
- />
-
- <active_rules id="1"
- profile_id="100"
- rule_id="10"
- failure_level="3"
- inheritance="[null]"
- created_at="1500000000000"
- updated_at="1600000000000"/>
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules id="10"
- name="Null Pointer"
- plugin_rule_key="S001"
- plugin_config_key="S1"
- plugin_name="xoo"
- description_format="HTML"
- description="S001 desc"
- language="xoo"
- priority="4"
- status="READY"
- is_template="[false]"
- template_id="[null]"
- system_tags="cwe"
- created_at="1500000000000"
- updated_at="1600000000000"/>
-
- <rules id="11"
- name="Slow"
- plugin_rule_key="S002"
- plugin_config_key="S2"
- plugin_name="xoo"
- description_format="MARKDOWN"
- description="*S002 desc*"
- language="xoo"
- priority="3"
- status="BETA"
- is_template="[true]"
- template_id="[null]"
- system_tags="[null]"
- created_at="2000000000000"
- updated_at="2100000000000"/>
-
- <rules_profiles id="1"
- name="Parent"
- organization_uuid="org-123"
- kee="parent"
- language="xoo"
- parent_kee="[null]"
- is_built_in="[false]"
- />
-
- <rules_profiles id="2"
- name="Child"
- organization_uuid="org-123"
- kee="child"
- language="xoo"
- parent_kee="parent"
- is_built_in="[false]"
- />
-
- <active_rules id="1"
- profile_id="2"
- rule_id="10"
- failure_level="4"
- inheritance="INHERITED"
- created_at="1500000000000"
- updated_at="1600000000000"/>
-
- <!-- Parent of Active rule 1 -->
- <active_rules id="2"
- profile_id="1"
- rule_id="10"
- failure_level="0"
- inheritance="[null]"
- created_at="1700000000000"
- updated_at="1800000000000"/>
-
- <rules_profiles id="3"
- name="Sonar Way"
- organization_uuid="org-123"
- kee="sonar-way"
- language="xoo"
- parent_kee="[null]"
- is_built_in="[false]"
- />
-
- <active_rules id="3"
- profile_id="3"
- rule_id="11"
- failure_level="3"
- inheritance="[null]"
- created_at="2000000000000"
- updated_at="2100000000000"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]"
- system_tags="[null]"
- id="1"
- plugin_rule_key="rule1"
- plugin_name="fake"
- plugin_config_key="config1"
- name="One"
- description="Description of One"
- status="READY"
- priority="4"
- is_template="[false]"
- template_id="[null]"
- language="java"/>
-
- <rules tags="[null]"
- system_tags="[null]"
- id="2"
- plugin_rule_key="rule2"
- plugin_name="fake"
- plugin_config_key="[null]"
- name="Two"
- description="Description of Two"
- status="DEPRECATED"
- priority="0"
- is_template="[false]"
- template_id="[null]"
- language="java"/>
-
- <rules_parameters id="1"
- rule_id="1"
- default_value="default value one"
- description="parameter one"
- name="param1"
- param_type="STRING"/>
- <rules_parameters id="2"
- rule_id="1"
- default_value="default value two"
- description="parameter two"
- name="param2"
- param_type="STRING"/>
-
- <rules_profiles id="1"
- version="1"
- used_profile="true"
- organization_uuid="org-123"
- name="profile name"
- language="java"
- />
- <active_rules created_at="[null]"
- updated_at="[null]"
- id="1"
- rule_id="1"
- profile_id="1"
- failure_level="4"
- inheritance="[null]"/>
- <active_rule_parameters id="1"
- active_rule_id="1"
- rules_parameter_id="1"
- value="one"
- rules_parameter_key="[null]"/>
- <active_rule_parameters id="2"
- active_rule_id="1"
- rules_parameter_id="2"
- value="two"
- rules_parameter_key="[null]"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]"
- system_tags="[null]"
- id="1"
- plugin_rule_key="rule1"
- plugin_name="fake"
- plugin_config_key="old_config_key"
- name="old name"
- description="old description"
- status="READY"
- priority="2"
- is_template="[false]"
- template_id="[null]"/>
-
- <rules_parameters id="1"
- rule_id="1"
- name="param1"
- description="[null]"
- param_type="STRING"/>
- <rules_parameters id="2"
- rule_id="1"
- name="param2"
- description="[null]"
- param_type="STRING"/>
-
- <!-- to be removed -->
- <rules_parameters id="3"
- rule_id="1"
- name="param3"
- description="[null]"
- param_type="STRING"/>
-
-
- <rules_profiles id="1"
- version="1"
- used_profile="true"
- organization_uuid="org-123"
- name="profile name"
- language="java"
- />
- <active_rules created_at="[null]"
- updated_at="[null]"
- id="1"
- rule_id="1"
- profile_id="1"
- failure_level="4"/>
- <active_rule_parameters id="1"
- active_rule_id="1"
- rules_parameter_id="1"
- value="one"/>
- <active_rule_parameters id="2"
- active_rule_id="1"
- rules_parameter_id="2"
- value="two"/>
-
- <!-- to be removed -->
- <active_rule_parameters id="3"
- active_rule_id="1"
- rules_parameter_id="3"
- value="three"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]" system_tags="[null]" id="1" plugin_rule_key="deprecated-key" plugin_name="deprecated-repo" plugin_config_key="[null]" name="Deprecated" description="[null]"
- status="REMOVED" priority="4" is_template="[false]" template_id="[null]" language="[null]"/>
-
- <rules tags="[null]" system_tags="[null]" id="2" plugin_rule_key="deprecated" plugin_name="fake" plugin_config_key="[null]" name="Deprecated fake" description="[null]"
- status="REMOVED" priority="4" is_template="[false]" template_id="[null]" language="[null]"/>
-
- <rules tags="[null]" system_tags="[null]" id="3" plugin_rule_key="rule1" plugin_name="fake" plugin_config_key="config1" name="One" description="Description of One"
- status="READY" priority="4" is_template="[false]" template_id="[null]" language="java"/>
-
- <rules tags="[null]" system_tags="[null]" id="4" plugin_rule_key="rule2" plugin_name="fake" plugin_config_key="[null]" name="Two" description="Description of Two"
- status="DEPRECATED" priority="0" is_template="[false]" template_id="[null]" language="java"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]"
- system_tags="[null]"
- id="1"
- plugin_rule_key="deprecated-key"
- plugin_name="deprecated-repo"
- plugin_config_key="[null]"
- name="Deprecated"
- description="[null]"
- status="READY"
- priority="4"
- is_template="[false]"
- template_id="[null]"/>
-
- <rules tags="[null]"
- system_tags="[null]"
- id="2"
- plugin_rule_key="deprecated"
- plugin_name="fake"
- plugin_config_key="[null]"
- name="Deprecated fake"
- description="[null]"
- status="READY"
- priority="4"
- is_template="[false]"
- template_id="[null]"/>
-
- <rules_parameters id="1"
- rule_id="1"
- name="deprecated-prop"
- description="[null]"
- param_type="STRING"/>
-
- <rules_profiles id="1"
- version="1"
- organization_uuid="org-123"
- used_profile="true"
- name="sonar way"
- language="java"
- />
- <active_rules created_at="[null]"
- updated_at="[null]"
- id="1"
- rule_id="1"
- profile_id="1"
- failure_level="4"/>
- <active_rules created_at="[null]"
- updated_at="[null]"
- id="2"
- rule_id="2"
- profile_id="1"
- failure_level="0"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]" system_tags="[null]" id="1" plugin_rule_key="deprecated-key" plugin_name="deprecated-repo" plugin_config_key="[null]" name="Deprecated" description="[null]"
- status="REMOVED" priority="4" is_template="[false]" template_id="[null]" language="[null]"/>
-
- <rules tags="[null]" system_tags="[null]" id="2" plugin_rule_key="rule1" plugin_name="fake" plugin_config_key="config1" name="One" description="Description of One"
- status="READY" priority="4" is_template="[false]" template_id="[null]" language="java"/>
- <rules_parameters id="1" rule_id="2" default_value="default value one" description="parameter one" name="param1" param_type="STRING"/>
- <rules_parameters id="2" rule_id="2" default_value="default value two" description="parameter two" name="param2" param_type="STRING"/>
-
- <rules tags="[null]" system_tags="[null]" id="3" plugin_rule_key="rule2" plugin_name="fake" plugin_config_key="rule2" name="Two" description="Description of Two"
- status="DEPRECATED" priority="0" is_template="[false]" template_id="[null]" language="java"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]" system_tags="[null]" id="1" plugin_rule_key="deprecated-key" plugin_name="deprecated-repo" plugin_config_key="[null]" name="Deprecated" description="[null]"
- status="REMOVED" priority="4" is_template="[false]" template_id="[null]" language="[null]"/>
-
- <rules tags="[null]" system_tags="[null]" id="2" plugin_rule_key="deprecated" plugin_name="fake" plugin_config_key="[null]" name="Deprecated fake" description="[null]"
- status="REMOVED" priority="4" is_template="[false]" template_id="[null]" language="[null]"/>
-
- <rules_parameters id="1" rule_id="1" name="deprecated-prop" description="[null]" param_type="STRING" default_value="[null]"/>
-
- <rules tags="[null]" system_tags="[null]" id="3" plugin_rule_key="rule1" plugin_name="fake" plugin_config_key="config1" name="One" description="Description of One"
- status="READY" priority="4" is_template="[false]" template_id="[null]" language="java"/>
-
- <rules_parameters id="2" rule_id="3" default_value="default value one" description="parameter one" name="param1" param_type="STRING"/>
- <rules_parameters id="3" rule_id="3" default_value="default value two" description="parameter two" name="param2" param_type="STRING"/>
-
- <rules tags="[null]" system_tags="[null]" id="4" plugin_rule_key="rule2" plugin_name="fake" plugin_config_key="[null]" name="Two" description="Description of Two"
- status="DEPRECATED" priority="0" is_template="[false]" template_id="[null]" language="java"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]" system_tags="[null]" id="1" plugin_rule_key="deprecated-key" plugin_name="deprecated-repo" plugin_config_key="[null]" name="Deprecated" description="[null]"
- status="READY" priority="4" is_template="[false]" template_id="[null]"/>
-
- <rules tags="[null]" system_tags="[null]" id="2" plugin_rule_key="deprecated" plugin_name="fake" plugin_config_key="[null]" name="Deprecated fake" description="[null]"
- status="READY" priority="4" is_template="[false]" template_id="[null]"/>
-
- <rules_parameters id="1" rule_id="1" name="deprecated-prop" description="[null]" param_type="STRING"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]" system_tags="[null]" id="1" plugin_rule_key="disabled_rule" plugin_name="fake" plugin_config_key="[null]" name="Disabled rule" description="[null]"
- status="REMOVED" priority="4" is_template="[true]" template_id="[null]" language="[null]"/>
-
- <rules tags="[null]" system_tags="[null]" id="2" plugin_rule_key="user_rule" plugin_name="fake" plugin_config_key="[null]" name="User rule" description="[null]"
- status="REMOVED" priority="4" is_template="[false]" template_id="1" language="[null]"/>
-
- <rules tags="[null]" system_tags="[null]" id="3" plugin_rule_key="disabled_rule2" plugin_name="fake" plugin_config_key="old_config_key2" name="old name2" description="old description2"
- status="REMOVED" priority="1" is_template="[false]" template_id="[null]" language="[null]"/>
-
- <rules tags="[null]" system_tags="[null]" id="4" plugin_rule_key="template_rule2" plugin_name="fake" plugin_config_key="[null]" name="User rule" description="[null]"
- status="REMOVED" priority="4" is_template="[false]" template_id="3" language="[null]"/>
-
- <rules tags="[null]" system_tags="[null]" id="5" plugin_rule_key="rule1" plugin_name="fake" plugin_config_key="config1" name="One" description="Description of One"
- status="READY" priority="4" is_template="[false]" template_id="[null]" language="java"/>
-
- <rules tags="[null]" system_tags="[null]" id="6" plugin_rule_key="rule2" plugin_name="fake" plugin_config_key="[null]" name="Two" description="Description of Two"
- status="DEPRECATED" priority="0" is_template="[false]" template_id="[null]" language="java"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <!-- Rule as been removed -->
- <rules tags="[null]" system_tags="[null]" id="1" plugin_rule_key="disabled_rule" plugin_name="fake" plugin_config_key="[null]" name="Disabled rule" description="[null]"
- status="REMOVED" priority="4" is_template="[true]" template_id="[null]"/>
-
- <!-- user rule duplicated from rule 1. It is currently enabled. -->
- <rules tags="[null]" system_tags="[null]" id="2" plugin_rule_key="user_rule" plugin_name="fake" plugin_config_key="[null]" name="User rule" description="[null]"
- status="READY" priority="4" is_template="[false]" template_id="1"/>
-
- <!-- This rule will be removed... -->
- <rules tags="[null]" system_tags="[null]" id="3" plugin_rule_key="disabled_rule2" plugin_name="fake" plugin_config_key="old_config_key2" name="old name2" description="old description2"
- status="READY" priority="1" is_template="[false]" template_id="[null]" />
-
- <!-- ...so this template will be removed too -->
- <rules tags="[null]" system_tags="[null]" id="4" plugin_rule_key="template_rule2" plugin_name="fake" plugin_config_key="[null]" name="User rule" description="[null]"
- status="READY" priority="4" is_template="[false]" template_id="3"/>
-
-</dataset>
+++ /dev/null
-<dataset></dataset>
\ No newline at end of file
+++ /dev/null
-<dataset>
-
- <rules tags="[null]" system_tags="[null]" id="1" plugin_rule_key="rule1" plugin_name="findbugs" plugin_config_key="[null]" name="Rule One" description="Description of Rule One"
- status="READY" priority="2" is_template="[false]" template_id="[null]" language="java"/>
-
- <rules tags="[null]" system_tags="[null]" id="2" plugin_rule_key="rule2" plugin_name="findbugs" plugin_config_key="[null]" name="Rule Two" description="Description of Rule Two"
- status="READY" priority="2" is_template="[false]" template_id="[null]" language="java"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]" system_tags="[null]" id="1" plugin_rule_key="deprecated-key" plugin_name="deprecated-repo" plugin_config_key="[null]" name="Deprecated" description="[null]"
- status="REMOVED" priority="4" is_template="[false]" template_id="[null]" language="[null]"
- remediation_function="[null]" def_remediation_function="[null]"
- remediation_coeff="[null]" def_remediation_coeff="[null]"
- remediation_offset="[null]" def_remediation_offset="[null]"
- effort_to_fix_description="[null]"/>
-
- <rules tags="[null]" system_tags="[null]" id="2" plugin_rule_key="rule1" plugin_name="fake" plugin_config_key="config1" name="One" description="Description of One"
- status="READY" priority="4" is_template="[false]" template_id="[null]" language="java"
- remediation_function="[null]" def_remediation_function="LINEAR_OFFSET"
- remediation_coeff="[null]" def_remediation_coeff="5d"
- remediation_offset="[null]" def_remediation_offset="10h"
- effort_to_fix_description="squid.S115.effortToFix"/>
-
- <rules_parameters id="1" rule_id="2" default_value="default value one" description="parameter one" name="param1" param_type="STRING"/>
- <rules_parameters id="2" rule_id="2" default_value="default value two" description="parameter two" name="param2" param_type="STRING"/>
-
- <rules tags="[null]" system_tags="[null]" id="3" plugin_rule_key="rule2" plugin_name="fake" plugin_config_key="[null]" name="Two" description="Description of Two"
- status="DEPRECATED" priority="0" is_template="[false]" template_id="[null]" language="java"
- remediation_function="[null]" def_remediation_function="[null]"
- remediation_coeff="[null]" def_remediation_coeff="[null]"
- remediation_offset="[null]" def_remediation_offset="[null]"
- effort_to_fix_description="[null]"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]" system_tags="[null]" id="1" plugin_rule_key="deprecated-key" plugin_name="deprecated-repo" plugin_config_key="[null]" name="Deprecated" description="[null]"
- status="REMOVED" priority="4" is_template="[false]" template_id="[null]" language="[null]"
- remediation_function="[null]" def_remediation_function="[null]"
- remediation_coeff="[null]" def_remediation_coeff="[null]"
- remediation_offset="[null]" def_remediation_offset="[null]"
- effort_to_fix_description="[null]"
- updated_at="2014-03-16"/>
-
- <rules tags="[null]" system_tags="[null]" id="2" plugin_rule_key="deprecated" plugin_name="fake" plugin_config_key="[null]" name="Deprecated fake" description="[null]"
- status="REMOVED" priority="4" is_template="[false]" template_id="[null]" language="[null]"
- remediation_function="[null]" def_remediation_function="[null]"
- remediation_coeff="[null]" def_remediation_coeff="[null]"
- remediation_offset="[null]" def_remediation_offset="[null]"
- effort_to_fix_description="[null]"
- updated_at="2014-03-16"/>
-
- <!-- New rules -->
- <rules tags="[null]" system_tags="[null]" id="3" plugin_rule_key="rule1" plugin_name="fake" plugin_config_key="config1" name="One" description="Description of One"
- status="READY" priority="4" is_template="[false]" template_id="[null]" language="java"
- remediation_function="[null]" def_remediation_function="LINEAR_OFFSET"
- remediation_coeff="[null]" def_remediation_coeff="5d"
- remediation_offset="[null]" def_remediation_offset="10h"
- effort_to_fix_description="squid.S115.effortToFix"
- updated_at="2014-03-17 19:10:03.0"/>
-
- <rules tags="[null]" system_tags="[null]" id="4" plugin_rule_key="rule2" plugin_name="fake" plugin_config_key="[null]" name="Two" description="Description of Two"
- status="DEPRECATED" priority="0" is_template="[false]" template_id="[null]" language="java"
- remediation_function="[null]" def_remediation_function="[null]"
- remediation_coeff="[null]" def_remediation_coeff="[null]"
- remediation_offset="[null]" def_remediation_offset="[null]"
- effort_to_fix_description="[null]"
- updated_at="2014-03-17 19:10:03.0"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]" system_tags="[null]" id="1" plugin_rule_key="deprecated-key" plugin_name="deprecated-repo" plugin_config_key="[null]" name="Deprecated" description="[null]"
- status="REMOVED" priority="4" is_template="[false]" template_id="[null]"
- remediation_function="[null]" def_remediation_function="[null]"
- remediation_coeff="[null]" def_remediation_coeff="[null]"
- remediation_offset="[null]" def_remediation_offset="[null]"
- effort_to_fix_description="[null]"
- updated_at="2014-03-16"/>
-
- <rules tags="[null]" system_tags="[null]" id="2" plugin_rule_key="deprecated" plugin_name="fake" plugin_config_key="[null]" name="Deprecated fake" description="[null]"
- status="REMOVED" priority="4" is_template="[false]" template_id="[null]"
- remediation_function="[null]" def_remediation_function="[null]"
- remediation_coeff="[null]" def_remediation_coeff="[null]"
- remediation_offset="[null]" def_remediation_offset="[null]"
- effort_to_fix_description="[null]"
- updated_at="2014-03-16"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]" system_tags="[null]" id="1" plugin_rule_key="PerformanceIssue" plugin_name="manual" plugin_config_key="[null]" name="Performance Issue" description="[null]"
- status="READY" priority="[null]" is_template="[false]" template_id="[null]" language="[null]"/>
-
- <rules tags="[null]" system_tags="[null]" id="2" plugin_rule_key="IllegalExceptionCheck" plugin_name="checkstyle" plugin_config_key="[null]" name="Illegal Exception" description="[null]"
- status="REMOVED" priority="4" is_template="[false]" template_id="[null]" language="[null]"/>
-
- <rules tags="[null]" system_tags="[null]" id="3" plugin_rule_key="rule1" plugin_name="fake" plugin_config_key="config1" name="One" description="Description of One"
- status="READY" priority="4" is_template="[false]" template_id="[null]" language="java"/>
-
- <rules tags="[null]" system_tags="[null]" id="4" plugin_rule_key="rule2" plugin_name="fake" plugin_config_key="[null]" name="Two" description="Description of Two"
- status="DEPRECATED" priority="0" is_template="[false]" template_id="[null]" language="java"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]" system_tags="[null]" id="1" plugin_rule_key="PerformanceIssue" plugin_name="manual" plugin_config_key="[null]" name="Performance Issue" description="[null]"
- status="READY" priority="[null]" is_template="[false]" template_id="[null]"/>
-
- <rules tags="[null]" system_tags="[null]" id="2" plugin_rule_key="IllegalExceptionCheck" plugin_name="checkstyle" plugin_config_key="[null]" name="Illegal Exception" description="[null]"
- status="READY" priority="4" is_template="[false]" template_id="[null]"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]" system_tags="[null]" id="1" plugin_rule_key="rule1" plugin_name="fake" plugin_config_key="config1" name="One" description="Description of One"
- status="READY" priority="4" is_template="[false]" template_id="[null]" language="java"/>
-
- <rules tags="[null]" system_tags="[null]" id="2" plugin_rule_key="user_rule" plugin_name="fake" plugin_config_key="[null]" name="User rule" description="[null]"
- status="READY" priority="4" is_template="[false]" template_id="1" language="java"/>
-
- <rules tags="[null]" system_tags="[null]" id="3" plugin_rule_key="rule2" plugin_name="fake" plugin_config_key="[null]" name="Two" description="Description of Two"
- status="DEPRECATED" priority="0" is_template="[false]" template_id="[null]" language="java"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]" system_tags="[null]" id="1" plugin_rule_key="rule1" plugin_name="fake" plugin_config_key="[null]" name="Rule one" description="[null]"
- status="READY" priority="4" is_template="[true]" template_id="[null]"/>
-
- <rules tags="[null]" system_tags="[null]" id="2" plugin_rule_key="user_rule" plugin_name="fake" plugin_config_key="[null]" name="User rule" description="[null]"
- status="READY" priority="4" is_template="[false]" template_id="1"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]" system_tags="[null]" id="1" plugin_rule_key="deprecated-key" plugin_name="deprecated-repo" plugin_config_key="[null]" name="Deprecated" description="[null]"
- status="REMOVED" priority="4" is_template="[false]" template_id="[null]" language="java"/>
-
- <rules tags="[null]" system_tags="[null]" id="2" plugin_rule_key="rule2" plugin_name="fake" plugin_config_key="rule2" name="Two" description="Description of Two"
- status="DEPRECATED" priority="0" is_template="[false]" template_id="[null]" language="java"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]" system_tags="[null]" id="1" plugin_rule_key="deprecated-key" plugin_name="deprecated-repo" plugin_config_key="[null]" name="Deprecated" description="[null]"
- status="REMOVED" priority="4" is_template="[false]" template_id="[null]"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]" system_tags="[null]" id="1" plugin_rule_key="deprecated-key" plugin_name="fake" plugin_config_key="[null]" name="Deprecated" description="[null]"
- status="READY" priority="4" is_template="[false]" template_id="[null]"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]" system_tags="[null]" id="1" plugin_rule_key="rule1" plugin_name="fake" plugin_config_key="config1" name="One" description="Description of One"
- status="READY" priority="4" is_template="[false]" template_id="[null]" language="java"/>
-
- <rules tags="[null]" system_tags="[null]" id="2" plugin_rule_key="rule2" plugin_name="fake" plugin_config_key="[null]" name="Two" description="Description of Two"
- status="DEPRECATED" priority="0" is_template="[false]" template_id="[null]" language="java"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]" system_tags="[null]" id="1" plugin_rule_key="rule1" plugin_name="fake" plugin_config_key="[null]" name="Old name" description="Old description"
- status="REMOVED" priority="4" is_template="[false]" template_id="[null]"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]" system_tags="[null]" id="1" plugin_rule_key="rule1" plugin_name="fake" plugin_config_key="config1" name="One" description="Description of One"
- status="READY" priority="4" is_template="[false]" template_id="[null]" language="java"/>
-
- <rules tags="[null]" system_tags="[null]" id="2" plugin_rule_key="user_rule" plugin_name="fake" plugin_config_key="[null]" name="User rule" description="[null]"
- status="READY" priority="4" is_template="[false]" template_id="1" language="java"/>
-
- <rules tags="[null]" system_tags="[null]" id="3" plugin_rule_key="rule2" plugin_name="fake" plugin_config_key="[null]" name="Two" description="Description of Two"
- status="DEPRECATED" priority="0" is_template="[false]" template_id="[null]" language="java"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]" system_tags="[null]" id="1" plugin_rule_key="rule1" plugin_name="fake" plugin_config_key="config1" name="One" description="Description of One"
- status="REMOVED" priority="4" is_template="[false]" template_id="[null]" language="java"/>
-
- <rules tags="[null]" system_tags="[null]" id="2" plugin_rule_key="user_rule" plugin_name="fake" plugin_config_key="[null]" name="User rule" description="[null]"
- status="REMOVED" priority="4" is_template="[false]" template_id="1" language="java"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]" system_tags="[null]" id="1" plugin_rule_key="rule1" plugin_name="fake" plugin_config_key="config1" name="One" description="Description of One"
- status="READY" priority="4" is_template="[false]" template_id="[null]" language="java"
- remediation_function="[null]" def_remediation_function="[null]"
- remediation_coeff="[null]" def_remediation_coeff="[null]"
- remediation_offset="[null]" def_remediation_offset="[null]"
- effort_to_fix_description="[null]"/>
-
- <rules tags="[null]" system_tags="[null]" id="2" plugin_rule_key="rule2" plugin_name="fake" plugin_config_key="[null]" name="Two" description="Description of Two"
- status="DEPRECATED" priority="0" is_template="[false]" template_id="[null]" language="java"
- remediation_function="[null]" def_remediation_function="[null]"
- remediation_coeff="[null]" def_remediation_coeff="[null]"
- remediation_offset="[null]" def_remediation_offset="[null]"
- effort_to_fix_description="[null]"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]" system_tags="[null]" id="1" plugin_rule_key="rule1" plugin_name="fake" plugin_config_key="old_config_key" name="old name" description="old description"
- status="READY" priority="2" is_template="[false]" template_id="[null]"
- remediation_function="[null]" def_remediation_function="LINEAR"
- remediation_coeff="[null]" def_remediation_coeff="14min"
- remediation_offset="[null]" def_remediation_offset="[null]"
- effort_to_fix_description="[null]"/>
-
- <rules tags="[null]" system_tags="[null]" id="2" plugin_rule_key="rule2" plugin_name="fake" plugin_config_key="old_config_key2" name="old name2" description="old description2"
- status="READY" priority="1" is_template="[false]" template_id="[null]"/>
-
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]" system_tags="[null]" id="1" plugin_rule_key="rule1" plugin_name="fake" plugin_config_key="config1" name="One" description="Description of One"
- status="READY" priority="4" is_template="[false]" template_id="[null]" language="java"
- remediation_function="[null]" def_remediation_function="[null]"
- remediation_coeff="[null]" def_remediation_coeff="[null]"
- remediation_offset="[null]" def_remediation_offset="[null]"
- effort_to_fix_description="[null]"/>
-
- <rules tags="[null]" system_tags="[null]" id="2" plugin_rule_key="rule2" plugin_name="fake" plugin_config_key="[null]" name="Two" description="Description of Two"
- status="DEPRECATED" priority="0" is_template="[false]" template_id="[null]" language="java"
- remediation_function="[null]" def_remediation_function="[null]"
- remediation_coeff="[null]" def_remediation_coeff="[null]"
- remediation_offset="[null]" def_remediation_offset="[null]"
- effort_to_fix_description="[null]"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]" system_tags="[null]" id="1" plugin_rule_key="rule1" plugin_name="fake" plugin_config_key="old_config_key" name="old name" description="old description"
- status="READY" priority="2" is_template="[false]" template_id="[null]"
- remediation_function="[null]" def_remediation_function="[null]"
- remediation_coeff="[null]" def_remediation_coeff="[null]"
- remediation_offset="[null]" def_remediation_offset="[null]"
- effort_to_fix_description="[null]"/>
-
- <rules tags="[null]" system_tags="[null]" id="2" plugin_rule_key="rule2" plugin_name="fake" plugin_config_key="old_config_key2" name="old name2" description="old description2"
- status="READY" priority="1" is_template="[false]" template_id="[null]"
- remediation_function="[null]" def_remediation_function="[null]"
- remediation_coeff="[null]" def_remediation_coeff="[null]"
- remediation_offset="[null]" def_remediation_offset="[null]"
- effort_to_fix_description="[null]"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]" system_tags="[null]" id="1" plugin_rule_key="rule1" plugin_name="fake" plugin_config_key="config1" name="One" description="Description of One"
- status="READY" priority="4" is_template="[false]" template_id="[null]" language="java"
- remediation_function="LINEAR_OFFSET" def_remediation_function="[null]"
- remediation_coeff="5d" def_remediation_coeff="[null]"
- remediation_offset="10h" def_remediation_offset="[null]"
- effort_to_fix_description="[null]"/>
-
- <rules tags="[null]" system_tags="[null]" id="2" plugin_rule_key="rule2" plugin_name="fake" plugin_config_key="[null]" name="Two" description="Description of Two"
- status="DEPRECATED" priority="0" is_template="[false]" template_id="[null]" language="java"
- remediation_function="[null]" def_remediation_function="[null]"
- remediation_coeff="[null]" def_remediation_coeff="[null]"
- remediation_offset="[null]" def_remediation_offset="[null]"
- effort_to_fix_description="[null]"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]" system_tags="[null]" id="1" plugin_rule_key="rule1" plugin_name="fake" plugin_config_key="old_config_key" name="old name" description="old description"
- status="READY" priority="2" is_template="[false]" template_id="[null]"
- remediation_function="LINEAR_OFFSET" def_remediation_function="[null]"
- remediation_coeff="5d" def_remediation_coeff="[null]"
- remediation_offset="10h" def_remediation_offset="[null]"
- effort_to_fix_description="[null]"/>
-
- <rules tags="[null]" system_tags="[null]" id="2" plugin_rule_key="rule2" plugin_name="fake" plugin_config_key="old_config_key2" name="old name2" description="old description2"
- status="READY" priority="1" is_template="[false]" template_id="[null]"
- remediation_function="[null]" def_remediation_function="[null]"
- remediation_coeff="[null]" def_remediation_coeff="[null]"
- remediation_offset="[null]" def_remediation_offset="[null]"
- effort_to_fix_description="[null]"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]" system_tags="[null]" id="1" plugin_rule_key="deprecated-key" plugin_name="deprecated-repo" plugin_config_key="[null]" name="Deprecated" description="[null]"
- status="READY" priority="4" is_template="[false]" template_id="[null]"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]" system_tags="[null]" id="1" plugin_rule_key="rule1" plugin_name="fake" plugin_config_key="config1" name="The One" description="The Description of One"
- status="READY" priority="4" is_template="[false]" template_id="[null]" language="java"/>
-
- <rules tags="[null]" system_tags="[null]" id="2" plugin_rule_key="rule2" plugin_name="fake" plugin_config_key="rule2" name="Two" description="Description of Two"
- status="DEPRECATED" priority="0" is_template="[false]" template_id="[null]" language="java"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]" system_tags="[null]" id="1" plugin_rule_key="rule1" plugin_name="fake" plugin_config_key="config1" name="One" description="Description of One"
- status="READY" priority="4" is_template="[false]" template_id="[null]" language="java"
- remediation_function="[null]" def_remediation_function="LINEAR_OFFSET"
- remediation_coeff="[null]" def_remediation_coeff="5d"
- remediation_offset="[null]" def_remediation_offset="10h"
- effort_to_fix_description="squid.S115.effortToFix"/>
-
- <rules_parameters id="1" rule_id="1" default_value="default value one" description="parameter one" name="param1" param_type="STRING"/>
- <rules_parameters id="2" rule_id="1" default_value="default value two" description="parameter two" name="param2" param_type="STRING"/>
-
- <rules tags="[null]" system_tags="[null]" id="2" plugin_rule_key="rule2" plugin_name="fake" plugin_config_key="[null]" name="Two" description="Description of Two"
- status="DEPRECATED" priority="0" is_template="[false]" template_id="[null]" language="java"
- remediation_function="[null]" def_remediation_function="[null]"
- remediation_coeff="[null]" def_remediation_coeff="[null]"
- remediation_offset="[null]" def_remediation_offset="[null]"
- effort_to_fix_description="[null]"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]" system_tags="[null]" id="1" plugin_rule_key="rule1" plugin_name="fake" plugin_config_key="old_config_key" name="old name" description="old description"
- status="READY" priority="2" is_template="[false]" template_id="[null]"
- remediation_function="[null]" def_remediation_function="LINEAR"
- remediation_coeff="[null]" def_remediation_coeff="14min"
- remediation_offset="[null]" def_remediation_offset="[null]"
- effort_to_fix_description="[null]"/>
-
- <rules_parameters id="1" rule_id="1" name="param1" description="[null]" param_type="STRING"/>
-
- <rules tags="[null]" system_tags="[null]" id="2" plugin_rule_key="rule2" plugin_name="fake" plugin_config_key="old_config_key2" name="old name2" description="old description2"
- status="READY" priority="1" is_template="[false]" template_id="[null]"/>
-
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]" system_tags="[null]" id="1" plugin_rule_key="rule1" plugin_name="fake" plugin_config_key="config1" name="One" description="Description of One"
- status="READY" priority="4" is_template="[false]" template_id="[null]" language="java"/>
- <rules_parameters id="1" rule_id="1" default_value="default value one" description="parameter one" name="param1" param_type="STRING"/>
- <rules_parameters id="3" rule_id="1" default_value="default value two" description="parameter two" name="param2" param_type="STRING"/>
-
- <rules tags="[null]" system_tags="[null]" id="2" plugin_rule_key="rule2" plugin_name="fake" plugin_config_key="[null]" name="Two" description="Description of Two"
- status="DEPRECATED" priority="0" is_template="[false]" template_id="[null]" language="java"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]" system_tags="[null]" id="1" plugin_rule_key="rule1" plugin_name="fake" plugin_config_key="old_config_key" name="old name" description="old description"
- status="READY" priority="2" is_template="[false]" template_id="[null]"/>
-
- <rules tags="[null]" system_tags="[null]" id="2" plugin_rule_key="rule2" plugin_name="fake" plugin_config_key="old_config_key2" name="old name2" description="old description2"
- status="READY" priority="1" is_template="[false]" template_id="[null]"/>
-
- <rules_parameters id="1" rule_id="1" name="param1" description="old description" param_type="STRING"/>
- <rules_parameters id="2" rule_id="1" name="deprecated_param" description="deprecated param to be removed" param_type="STRING"/>
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]" system_tags="[null]" id="1" plugin_rule_key="rule1" plugin_name="fake" plugin_config_key="config1" name="One" description="Description of One"
- status="READY" priority="4" is_template="[false]" template_id="[null]" language="java"
- remediation_function="[null]" def_remediation_function="LINEAR_OFFSET"
- remediation_coeff="[null]" def_remediation_coeff="5d"
- remediation_offset="[null]" def_remediation_offset="10h"
- effort_to_fix_description="squid.S115.effortToFix" />
-
- <!-- Instance of old rule 1 :/ -->
- <rules tags="[null]" system_tags="[null]" id="2" plugin_rule_key="template_rule1" plugin_name="fake" plugin_config_key="[null]" name="User rule" description="[null]"
- status="READY" priority="4" is_template="[false]" template_id="1" language="java"
- remediation_function="[null]" def_remediation_function="LINEAR_OFFSET"
- remediation_coeff="[null]" def_remediation_coeff="5d"
- remediation_offset="[null]" def_remediation_offset="10h"
- effort_to_fix_description="squid.S115.effortToFix" />
-
- <rules tags="[null]" system_tags="[null]" id="3" plugin_rule_key="rule2" plugin_name="fake" plugin_config_key="[null]" name="Two" description="Description of Two"
- status="DEPRECATED" priority="0" is_template="[false]" template_id="[null]" language="java"
- remediation_function="[null]" def_remediation_function="[null]"
- remediation_coeff="[null]" def_remediation_coeff="[null]"
- remediation_offset="[null]" def_remediation_offset="[null]"
- effort_to_fix_description="[null]" />
-
- <!-- Template of old rule 3 :/ -->
- <rules tags="[null]" system_tags="[null]" id="4" plugin_rule_key="template_rule2" plugin_name="fake" plugin_config_key="[null]" name="User rule" description="[null]"
- status="DEPRECATED" priority="4" is_template="[false]" template_id="3" language="java"
- remediation_function="[null]" def_remediation_function="[null]"
- remediation_coeff="[null]" def_remediation_coeff="[null]"
- remediation_offset="[null]" def_remediation_offset="[null]"
- effort_to_fix_description="[null]" />
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules tags="[null]" system_tags="[null]" id="1" plugin_rule_key="rule1" plugin_name="fake" plugin_config_key="[null]" name="Rule one" description="[null]"
- status="READY" priority="4" is_template="[true]" template_id="[null]" language="[null]"
- remediation_function="[null]" def_remediation_function="LINEAR_OFFSET"
- remediation_coeff="[null]" def_remediation_coeff="5d"
- remediation_offset="[null]" def_remediation_offset="10h"
- effort_to_fix_description="squid.S115.effortToFix" />
-
- <!-- Instance of rule 1 -->
- <rules tags="[null]" system_tags="[null]" id="2" plugin_rule_key="template_rule1" plugin_name="fake" plugin_config_key="[null]" name="User rule" description="[null]"
- status="READY" priority="4" is_template="[false]" template_id="1" language="[null]"
- remediation_function="[null]" def_remediation_function="LINEAR"
- remediation_coeff="[null]" def_remediation_coeff="1h"
- remediation_offset="[null]" def_remediation_offset="15min"
- effort_to_fix_description="squid.S115.effortToFix2" />
-
- <rules tags="[null]" system_tags="[null]" id="3" plugin_rule_key="rule2" plugin_name="fake" plugin_config_key="old_config_key2" name="old name2" description="old description2"
- status="DEPRECATED" priority="1" is_template="[true]" template_id="[null]"
- remediation_function="[null]" def_remediation_function="[null]"
- remediation_coeff="[null]" def_remediation_coeff="[null]"
- remediation_offset="[null]" def_remediation_offset="[null]"
- effort_to_fix_description="[null]" />
-
- <!-- Instance of rule 3 -->
- <rules tags="[null]" system_tags="[null]" id="4" plugin_rule_key="template_rule2" plugin_name="fake" plugin_config_key="[null]" name="User rule" description="[null]"
- status="READY" priority="4" is_template="[false]" template_id="3"
- remediation_function="[null]" def_remediation_function="[null]"
- remediation_coeff="[null]" def_remediation_coeff="[null]"
- remediation_offset="[null]" def_remediation_offset="[null]"
- effort_to_fix_description="[null]" />
-
-</dataset>
+++ /dev/null
-<dataset>
-
- <rules_profiles id="1"
- name="Java One"
- language="java"
- organization_uuid="org-123"
- parent_kee="[null]"
- kee="java-one"
- created_at="2014-01-20"
- updated_at="2014-01-20"
- rules_updated_at="2014-01-20T12:00:00+0000"/>
-
- <rules_profiles id="2"
- name="Java Two"
- language="java"
- organization_uuid="org-123"
- parent_kee="[null]"
- kee="java-two"
- created_at="2014-01-20"
- updated_at="2014-01-20"
- rules_updated_at="2014-01-20T12:00:00+0000"/>
-
- <rules_profiles id="3"
- name="Php One"
- language="php"
- organization_uuid="org-123"
- parent_kee="[null]"
- kee="php-one"
- created_at="2014-01-20"
- updated_at="2014-01-20"
- rules_updated_at="2014-01-20T12:00:00+0000"/>
-
- <rules_profiles id="4"
- name="Cobol One"
- language="cbl"
- organization_uuid="org-123"
- parent_kee="[null]"
- kee="cobol-one"
- created_at="2014-01-20"
- updated_at="2014-01-20"
- rules_updated_at="2014-01-20T12:00:00+0000"/>
-
-</dataset>
projects / sonarqube.git / commitdiff