"ce_task_input",
"ce_scanner_context",
"default_qprofiles",
+ "deprecated_rule_keys",
"duplications_index",
"es_queue",
"events",
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2018 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.rule;
+
+import java.util.Objects;
+import javax.annotation.CheckForNull;
+
+/**
+ * Map the table "deprecated_rule_keys"
+ */
+public class DeprecatedRuleKeyDto {
+ /**
+ * Uuid of the deprecated key
+ */
+ private String uuid;
+ /**
+ * the id of the current rule for this deprecated key
+ */
+ private Integer ruleId;
+ /**
+ * repository key that was deprecated
+ */
+ private String oldRepositoryKey;
+ /**
+ * rule key that was deprecated, not nullable
+ */
+ private String oldRuleKey;
+ /**
+ * creation date of the row
+ */
+ private Long createdAt;
+
+ /**
+ * current repository key retrieved from an external join on rule_id
+ */
+ private String newRepositoryKey;
+ /**
+ * current rule key retrieved from an external join on rule_id
+ */
+ private String newRuleKey;
+
+ public String getUuid() {
+ return uuid;
+ }
+
+ public DeprecatedRuleKeyDto setUuid(String uuid) {
+ this.uuid = uuid;
+ return this;
+ }
+
+ public Integer getRuleId() {
+ return ruleId;
+ }
+
+ public DeprecatedRuleKeyDto setRuleId(Integer ruleId) {
+ this.ruleId = ruleId;
+ return this;
+ }
+
+ public String getOldRepositoryKey() {
+ return oldRepositoryKey;
+ }
+
+ public DeprecatedRuleKeyDto setOldRepositoryKey(String oldRepositoryKey) {
+ this.oldRepositoryKey = oldRepositoryKey;
+ return this;
+ }
+
+ public String getOldRuleKey() {
+ return oldRuleKey;
+ }
+
+ public DeprecatedRuleKeyDto setOldRuleKey(String oldRuleKey) {
+ this.oldRuleKey = oldRuleKey;
+ return this;
+ }
+
+ /**
+ * This value may be null if the rule has been deleted
+ *
+ * @return the current repository key
+ */
+ @CheckForNull
+ public String getNewRepositoryKey() {
+ return newRepositoryKey;
+ }
+
+ /**
+ * This value may be null if the rule has been deleted
+ *
+ * @return the current rule key
+ */
+ @CheckForNull
+ public String getNewRuleKey() {
+ return newRuleKey;
+ }
+
+ public long getCreatedAt() {
+ return createdAt;
+ }
+
+ public DeprecatedRuleKeyDto setCreatedAt(long createdAt) {
+ this.createdAt = createdAt;
+ return this;
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(uuid);
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (obj == null || getClass() != obj.getClass()) {
+ return false;
+ }
+ final DeprecatedRuleKeyDto other = (DeprecatedRuleKeyDto) obj;
+ return Objects.equals(this.uuid, other.uuid);
+ }
+}
import java.util.Collection;
import java.util.List;
import java.util.Optional;
+import java.util.Set;
import java.util.function.Consumer;
import javax.annotation.Nullable;
import org.apache.ibatis.session.ResultHandler;
import static java.util.Optional.ofNullable;
import static org.sonar.db.DatabaseUtils.executeLargeInputs;
import static org.sonar.db.DatabaseUtils.executeLargeInputsWithoutOutput;
+import static org.sonar.db.DatabaseUtils.executeLargeUpdates;
public class RuleDao implements Dao {
mapper(session).deleteParameter(ruleParameterId);
}
+ public Set<DeprecatedRuleKeyDto> selectAllDeprecatedRuleKeys(DbSession session) {
+ return mapper(session).selectAllDeprecatedRuleKeys();
+ }
+
+ public void deleteDeprecatedRuleKeys(DbSession dbSession, Collection<String> uuids) {
+ if (uuids.isEmpty()) {
+ return;
+ }
+ executeLargeUpdates(uuids, mapper(dbSession)::deleteDeprecatedRuleKeys);
+ }
+
+ public void insert(DbSession dbSession, DeprecatedRuleKeyDto deprecatedRuleKey) {
+ mapper(dbSession).insertDeprecatedRuleKey(deprecatedRuleKey);
+ }
}
package org.sonar.db.rule;
import java.util.List;
+import java.util.Set;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.session.ResultHandler;
import org.sonar.db.es.RuleExtensionId;
void updateParameter(RuleParamDto param);
void deleteParameter(Integer paramId);
+
+ Set<DeprecatedRuleKeyDto> selectAllDeprecatedRuleKeys();
+
+ void deleteDeprecatedRuleKeys(@Param("uuids") List<String> uuids);
+
+ void insertDeprecatedRuleKey(DeprecatedRuleKeyDto deprecatedRuleKeyDto);
}
where
id=#{id,jdbcType=INTEGER}
</update>
+
+ <select id="selectAllDeprecatedRuleKeys" resultType="org.sonar.db.rule.DeprecatedRuleKeyDto">
+ SELECT
+ drk.uuid,
+ drk.rule_id as "ruleId",
+ drk.old_repository_key as "oldRepositoryKey",
+ drk.old_rule_key as "oldRuleKey",
+ r.plugin_rule_key as "newRuleKey",
+ r.plugin_name as "newRepositoryKey",
+ drk.created_at as "createdAt"
+ FROM
+ deprecated_rule_keys drk
+ LEFT OUTER JOIN rules r on r.id = drk.rule_id
+ </select>
+
+ <delete id="deleteDeprecatedRuleKeys">
+ DELETE FROM
+ deprecated_rule_keys
+ WHERE
+ <foreach collection="uuids" index="index" item="uuid" open="" separator=" or " close="">
+ uuid=#{uuid,jdbcType=INTEGER}
+ </foreach>
+ </delete>
+
+ <insert id="insertDeprecatedRuleKey" parameterType="org.sonar.db.rule.DeprecatedRuleKeyDto" keyColumn="uuid" useGeneratedKeys="false" keyProperty="uuid">
+ INSERT INTO deprecated_rule_keys (
+ uuid,
+ rule_id,
+ old_repository_key,
+ old_rule_key,
+ created_at
+ )
+ values (
+ #{uuid,jdbcType=VARCHAR},
+ #{ruleId,jdbcType=INTEGER},
+ #{oldRepositoryKey,jdbcType=VARCHAR},
+ #{oldRuleKey,jdbcType=VARCHAR},
+ #{createdAt,jdbcType=BIGINT}
+ )
+ </insert>
</mapper>
import java.util.Collections;
import java.util.List;
import java.util.Optional;
+import java.util.Set;
import java.util.function.Consumer;
+import org.apache.ibatis.exceptions.PersistenceException;
import org.apache.ibatis.session.ResultHandler;
import org.junit.Before;
import org.junit.Rule;
import static com.google.common.collect.Sets.newHashSet;
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;
@Test
public void scrollIndexingRulesByKeys_scrolls_nothing_if_key_does_not_exist() {
Accumulator<RuleForIndexingDto> accumulator = new Accumulator<>();
- RuleDefinitionDto r1 = db.rules().insert();
+ db.rules().insert();
underTest.scrollIndexingRulesByKeys(db.getSession(), singletonList(RuleKey.of("does", "not exist")), accumulator);
RuleMetadataDto r1Extension = db.rules().insertOrUpdateMetadata(r1, organization, r -> r.setTagsField("t1,t2"));
RuleExtensionId r1ExtensionId = new RuleExtensionId(organization.getUuid(), r1.getRepositoryKey(), r1.getRuleKey());
RuleDefinitionDto r2 = db.rules().insert();
- RuleMetadataDto r2Extension = db.rules().insertOrUpdateMetadata(r2, organization, r -> r.setTagsField("t1,t3"));
+ db.rules().insertOrUpdateMetadata(r2, organization, r -> r.setTagsField("t1,t3"));
underTest.scrollIndexingRuleExtensionsByIds(db.getSession(), singletonList(r1ExtensionId), accumulator);
tuple(r1.getKey(), organization.getUuid(), r1Extension.getTagsAsString()));
}
- private static class Accumulator<T> implements Consumer<T> {
+ @Test
+ public void selectAllDeprecatedRuleKeys() {
+ RuleDefinitionDto r1 = db.rules().insert();
+ RuleDefinitionDto r2 = db.rules().insert();
+
+ db.rules().insertDeprecatedKey(r -> r.setRuleId(r1.getId()));
+ db.rules().insertDeprecatedKey(r -> r.setRuleId(r2.getId()));
+
+ db.getSession().commit();
+
+ Set<DeprecatedRuleKeyDto> deprecatedRuleKeyDtos = underTest.selectAllDeprecatedRuleKeys(db.getSession());
+ assertThat(deprecatedRuleKeyDtos).hasSize(2);
+ }
+
+ @Test
+ public void selectAllDeprecatedRuleKeys_return_values_even_if_there_is_no_rule() {
+ db.rules().insertDeprecatedKey();
+ db.rules().insertDeprecatedKey();
+
+ Set<DeprecatedRuleKeyDto> deprecatedRuleKeyDtos = underTest.selectAllDeprecatedRuleKeys(db.getSession());
+ assertThat(deprecatedRuleKeyDtos).hasSize(2);
+ assertThat(deprecatedRuleKeyDtos)
+ .extracting(DeprecatedRuleKeyDto::getNewRepositoryKey, DeprecatedRuleKeyDto::getNewRuleKey)
+ .containsExactly(
+ tuple(null, null),
+ tuple(null, null)
+ );
+ }
+
+ @Test
+ public void deleteDeprecatedRuleKeys_with_empty_list_has_no_effect() {
+ db.rules().insertDeprecatedKey();
+ db.rules().insertDeprecatedKey();
+
+ assertThat(underTest.selectAllDeprecatedRuleKeys(db.getSession())).hasSize(2);
+
+ underTest.deleteDeprecatedRuleKeys(db.getSession(), emptyList());
+
+ assertThat(underTest.selectAllDeprecatedRuleKeys(db.getSession())).hasSize(2);
+ }
+
+ @Test
+ public void deleteDeprecatedRuleKeys_with_non_existing_uuid_has_no_effect() {
+ db.rules().insertDeprecatedKey(d -> d.setUuid("A1"));
+ db.rules().insertDeprecatedKey(d -> d.setUuid("A2"));
+
+ assertThat(underTest.selectAllDeprecatedRuleKeys(db.getSession())).hasSize(2);
+
+ underTest.deleteDeprecatedRuleKeys(db.getSession(), asList("B1", "B2"));
+
+ assertThat(underTest.selectAllDeprecatedRuleKeys(db.getSession())).hasSize(2);
+ }
+
+ @Test
+ public void deleteDeprecatedRuleKeys() {
+ DeprecatedRuleKeyDto deprecatedRuleKeyDto1 = db.rules().insertDeprecatedKey();
+ db.rules().insertDeprecatedKey();;
+
+ assertThat(underTest.selectAllDeprecatedRuleKeys(db.getSession())).hasSize(2);
+
+ underTest.deleteDeprecatedRuleKeys(db.getSession(), singletonList(deprecatedRuleKeyDto1.getUuid()));
+ assertThat(underTest.selectAllDeprecatedRuleKeys(db.getSession())).hasSize(1);
+ }
+
+ @Test
+ public void insertDeprecatedRuleKey() {
+ RuleDefinitionDto r1 = db.rules().insert();
+ DeprecatedRuleKeyDto deprecatedRuleKeyDto = db.rules().insertDeprecatedKey(d -> d.setRuleId(r1.getId()));
+
+ db.getSession().commit();
+
+ Set<DeprecatedRuleKeyDto> deprecatedRuleKeyDtos = underTest.selectAllDeprecatedRuleKeys(db.getSession());
+ assertThat(deprecatedRuleKeyDtos).hasSize(1);
+
+ DeprecatedRuleKeyDto deprecatedRuleKeyDto1 = deprecatedRuleKeyDtos.iterator().next();
+ assertThat(deprecatedRuleKeyDto1.getOldRepositoryKey()).isEqualTo(deprecatedRuleKeyDto.getOldRepositoryKey());
+ assertThat(deprecatedRuleKeyDto1.getOldRuleKey()).isEqualTo(deprecatedRuleKeyDto.getOldRuleKey());
+ assertThat(deprecatedRuleKeyDto1.getNewRepositoryKey()).isEqualTo(r1.getRepositoryKey());
+ assertThat(deprecatedRuleKeyDto1.getNewRuleKey()).isEqualTo(r1.getRuleKey());
+ assertThat(deprecatedRuleKeyDto1.getUuid()).isEqualTo(deprecatedRuleKeyDto.getUuid());
+ assertThat(deprecatedRuleKeyDto1.getCreatedAt()).isEqualTo(deprecatedRuleKeyDto.getCreatedAt());
+ assertThat(deprecatedRuleKeyDto1.getRuleId()).isEqualTo(r1.getId());
+ }
+
+ @Test
+ public void insertDeprecatedRuleKey_with_same_RuleKey_should_fail() {
+ String repositoryKey = randomAlphanumeric(50);
+ String ruleKey = randomAlphanumeric(50);
+ db.rules().insertDeprecatedKey(d -> d.setOldRepositoryKey(repositoryKey)
+ .setOldRuleKey(ruleKey));
+
+ thrown.expect(PersistenceException.class);
+
+ db.rules().insertDeprecatedKey(d -> d.setOldRepositoryKey(repositoryKey)
+ .setOldRuleKey(ruleKey));
+ }
+
+ private static class Accumulator<T> implements Consumer<T> {
private final List<T> list = new ArrayList<>();
@Override
*/
package org.sonar.db.rule;
-import java.util.Arrays;
import java.util.function.Consumer;
import org.sonar.api.rule.RuleKey;
import org.sonar.api.server.rule.RuleParamType;
import org.sonar.db.DbTester;
import org.sonar.db.organization.OrganizationDto;
+import static java.util.Arrays.asList;
import static org.apache.commons.lang.RandomStringUtils.randomAlphabetic;
+import static org.sonar.db.rule.RuleTesting.newDeprecatedRuleKey;
import static org.sonar.db.rule.RuleTesting.newRule;
import static org.sonar.db.rule.RuleTesting.newRuleDto;
@SafeVarargs
public final RuleDefinitionDto insert(Consumer<RuleDefinitionDto>... populaters) {
RuleDefinitionDto rule = newRule();
- Arrays.asList(populaters).forEach(populater -> populater.accept(rule));
+ asList(populaters).forEach(populater -> populater.accept(rule));
return insert(rule);
}
@SafeVarargs
public final RuleMetadataDto insertOrUpdateMetadata(RuleDefinitionDto rule, OrganizationDto organization, Consumer<RuleMetadataDto>... populaters) {
RuleMetadataDto dto = RuleTesting.newRuleMetadata(rule, organization);
- Arrays.asList(populaters).forEach(populater -> populater.accept(dto));
+ asList(populaters).forEach(populater -> populater.accept(dto));
return insertOrUpdateMetadata(dto);
}
@SafeVarargs
public final RuleParamDto insertRuleParam(RuleDefinitionDto rule, Consumer<RuleParamDto>... populaters) {
RuleParamDto param = RuleTesting.newRuleParam(rule);
- Arrays.asList(populaters).forEach(populater -> populater.accept(param));
+ asList(populaters).forEach(populater -> populater.accept(param));
db.getDbClient().ruleDao().insertRuleParam(db.getSession(), rule, param);
db.commit();
return param;
@SafeVarargs
public final RuleDto insertRule(OrganizationDto organization, Consumer<RuleDto>... populaters) {
RuleDto ruleDto = newRuleDto(organization);
- Arrays.asList(populaters).forEach(populater -> populater.accept(ruleDto));
+ asList(populaters).forEach(populater -> populater.accept(ruleDto));
return insertRule(ruleDto);
}
return insertRule(ruleDto);
}
+ @SafeVarargs
+ public final DeprecatedRuleKeyDto insertDeprecatedKey(Consumer<DeprecatedRuleKeyDto>... deprecatedRuleKeyDtoConsumers) {
+ DeprecatedRuleKeyDto deprecatedRuleKeyDto = newDeprecatedRuleKey();
+ asList(deprecatedRuleKeyDtoConsumers).forEach(c -> c.accept(deprecatedRuleKeyDto));
+ db.getDbClient().ruleDao().insert(db.getSession(), deprecatedRuleKeyDto);
+ return deprecatedRuleKeyDto;
+ }
+
+
public RuleParamDto insertRuleParam(RuleDto rule) {
RuleParamDto param = new RuleParamDto();
param.setRuleId(rule.getId());
import org.sonar.api.rule.Severity;
import org.sonar.api.rules.RuleType;
import org.sonar.api.server.rule.RuleParamType;
+import org.sonar.core.util.UuidFactory;
+import org.sonar.core.util.UuidFactoryFast;
import org.sonar.db.organization.OrganizationDto;
import org.sonar.db.rule.RuleDto.Format;
import org.sonar.db.rule.RuleDto.Scope;
public static final RuleKey XOO_X2 = RuleKey.of("xoo", "x2");
public static final RuleKey XOO_X3 = RuleKey.of("xoo", "x3");
+ private static final UuidFactory uuidFactory = UuidFactoryFast.getInstance();
+
private RuleTesting() {
// only static helpers
}
.setType(RuleParamType.STRING.type());
}
+ public static DeprecatedRuleKeyDto newDeprecatedRuleKey() {
+ return new DeprecatedRuleKeyDto()
+ .setUuid(uuidFactory.create())
+ .setOldRepositoryKey(randomAlphanumeric(50))
+ .setOldRuleKey(randomAlphanumeric(50))
+ .setRuleId(nextInt(100_000))
+ .setCreatedAt(System.currentTimeMillis());
+ }
+
/**
* @deprecated use newRule(...)
*/
import com.google.common.collect.Iterables;
import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
import java.util.ArrayList;
import java.util.Collection;
-import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
+import java.util.Set;
import java.util.stream.Collectors;
import javax.annotation.Nullable;
import org.apache.commons.lang.ObjectUtils;
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.UuidFactory;
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.ActiveRuleParamDto;
+import org.sonar.db.rule.DeprecatedRuleKeyDto;
import org.sonar.db.rule.RuleDefinitionDto;
import org.sonar.db.rule.RuleDto.Format;
import org.sonar.db.rule.RuleDto.Scope;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.collect.Lists.newArrayList;
+import static com.google.common.collect.Sets.difference;
import static java.lang.String.format;
+import static java.util.Collections.emptySet;
+import static java.util.stream.Collectors.toSet;
/**
* Register rules at server startup
private final System2 system2;
private final OrganizationFlags organizationFlags;
private final WebServerRuleFinder webServerRuleFinder;
+ private final UuidFactory uuidFactory;
public RegisterRules(RuleDefinitionsLoader defLoader, QProfileRules qProfileRules, DbClient dbClient, RuleIndexer ruleIndexer,
ActiveRuleIndexer activeRuleIndexer, Languages languages, System2 system2, OrganizationFlags organizationFlags,
- WebServerRuleFinder webServerRuleFinder) {
+ WebServerRuleFinder webServerRuleFinder, UuidFactory uuidFactory) {
this.defLoader = defLoader;
this.qProfileRules = qProfileRules;
this.dbClient = dbClient;
this.system2 = system2;
this.organizationFlags = organizationFlags;
this.webServerRuleFinder = webServerRuleFinder;
+ this.uuidFactory = uuidFactory;
}
@Override
Profiler profiler = Profiler.create(LOG).startInfo("Register rules");
try (DbSession dbSession = dbClient.openSession(false)) {
Map<RuleKey, RuleDefinitionDto> allRules = loadRules(dbSession);
- List<RuleKey> keysToIndex = new ArrayList<>();
+ Map<Integer, Set<SingleDeprecatedRuleKey>> existingDeprecatedRuleKeys = loadDeprecatedRuleKeys(dbSession);
RulesDefinition.Context context = defLoader.load();
+
+ List<RulesDefinition.ExtendedRepository> repositories = getRepositories(context);
+
+ List<RuleKey> keysToIndex = new ArrayList<>();
boolean orgsEnabled = organizationFlags.isEnabled(dbSession);
- for (RulesDefinition.ExtendedRepository repoDef : getRepositories(context)) {
+
+ for (RulesDefinition.ExtendedRepository repoDef : repositories) {
if (languages.get(repoDef.language()) != null) {
for (RulesDefinition.Rule ruleDef : repoDef.rules()) {
RuleKey ruleKey = RuleKey.of(ruleDef.repository().key(), ruleDef.key());
+
if (ruleDef.template() && orgsEnabled) {
RuleDefinitionDto ruleDefinition = allRules.get(ruleKey);
if (ruleDefinition != null && ruleDefinition.getStatus() == RuleStatus.REMOVED) {
}
continue;
}
- boolean relevantForIndex = registerRule(ruleDef, allRules, dbSession);
+ boolean relevantForIndex = registerRule(ruleDef, allRules, existingDeprecatedRuleKeys, dbSession);
if (relevantForIndex) {
keysToIndex.add(ruleKey);
}
dbSession.commit();
}
}
+
List<RuleDefinitionDto> removedRules = processRemainingDbRules(allRules.values(), dbSession);
List<ActiveRuleChange> changes = removeActiveRulesOnStillExistingRepositories(dbSession, removedRules, context);
dbSession.commit();
}
}
+ @Override
+ public void stop() {
+ // nothing
+ }
+
private void persistRepositories(DbSession dbSession, List<RulesDefinition.Repository> repositories) {
dbClient.ruleRepositoryDao().truncate(dbSession);
List<RuleRepositoryDto> dtos = repositories
dbSession.commit();
}
- @Override
- public void stop() {
- // nothing
- }
-
- private boolean registerRule(RulesDefinition.Rule ruleDef, Map<RuleKey, RuleDefinitionDto> allRules, DbSession session) {
+ private boolean registerRule(RulesDefinition.Rule ruleDef, Map<RuleKey, RuleDefinitionDto> allRules, Map<Integer,
+ Set<SingleDeprecatedRuleKey>> existingDeprecatedRuleKeys, DbSession session) {
RuleKey ruleKey = RuleKey.of(ruleDef.repository().key(), ruleDef.key());
RuleDefinitionDto existingRule = allRules.remove(ruleKey);
newRule = false;
}
- boolean executeUpdate = false;
- if (mergeRule(ruleDef, rule)) {
- executeUpdate = true;
- }
-
- if (mergeDebtDefinitions(ruleDef, rule)) {
- executeUpdate = true;
- }
-
- if (mergeTags(ruleDef, rule)) {
- executeUpdate = true;
- }
+ boolean executeUpdate = mergeRule(ruleDef, rule);
+ executeUpdate |= mergeDebtDefinitions(ruleDef, rule);
+ executeUpdate |= mergeTags(ruleDef, rule);
if (executeUpdate) {
update(session, rule);
}
mergeParams(ruleDef, rule, session);
+ updateDeprecatedKeys(ruleDef, rule, existingDeprecatedRuleKeys, session);
return newRule || executeUpdate;
}
return rules;
}
+ private Map<Integer, Set<SingleDeprecatedRuleKey>> loadDeprecatedRuleKeys(DbSession dbSession) {
+ return dbClient.ruleDao().selectAllDeprecatedRuleKeys(dbSession)
+ .stream()
+ .map(SingleDeprecatedRuleKey::from)
+ .collect(Collectors.groupingBy(SingleDeprecatedRuleKey::getRuleId, toSet()));
+ }
+
+
private List<RulesDefinition.ExtendedRepository> getRepositories(RulesDefinition.Context context) {
List<RulesDefinition.ExtendedRepository> repositories = new ArrayList<>();
for (RulesDefinition.Repository repoDef : context.repositories()) {
}
}
- private boolean mergeRule(RulesDefinition.Rule def, RuleDefinitionDto dto) {
+ private static boolean mergeRule(RulesDefinition.Rule def, RuleDefinitionDto dto) {
boolean changed = false;
if (!StringUtils.equals(dto.getName(), def.name())) {
dto.setName(def.name());
return changed;
}
- private boolean mergeDescription(RulesDefinition.Rule def, RuleDefinitionDto dto) {
+ private static boolean mergeDescription(RulesDefinition.Rule def, RuleDefinitionDto dto) {
boolean changed = false;
if (def.htmlDescription() != null && !StringUtils.equals(dto.getDescription(), def.htmlDescription())) {
dto.setDescription(def.htmlDescription());
return changed;
}
- private boolean mergeDebtDefinitions(RulesDefinition.Rule def, RuleDefinitionDto dto) {
+ private static boolean mergeDebtDefinitions(RulesDefinition.Rule def, RuleDefinitionDto dto) {
// Debt definitions are set to null if the sub-characteristic and the remediation function are null
DebtRemediationFunction debtRemediationFunction = def.debtRemediationFunction();
boolean hasDebt = debtRemediationFunction != null;
return mergeDebtDefinitions(dto, null, null, null, null);
}
- private boolean mergeDebtDefinitions(RuleDefinitionDto dto, @Nullable String remediationFunction,
+ private static boolean mergeDebtDefinitions(RuleDefinitionDto dto, @Nullable String remediationFunction,
@Nullable String remediationCoefficient, @Nullable String remediationOffset, @Nullable String effortToFixDescription) {
boolean changed = false;
}
}
- private boolean mergeParam(RuleParamDto paramDto, RulesDefinition.Param paramDef) {
+ private static boolean mergeParam(RuleParamDto paramDto, RulesDefinition.Param paramDef) {
boolean changed = false;
if (!StringUtils.equals(paramDto.getType(), paramDef.type().toString())) {
paramDto.setType(paramDef.type().toString());
boolean changed = false;
if (RuleStatus.REMOVED == ruleDef.status()) {
- dto.setSystemTags(Collections.emptySet());
+ dto.setSystemTags(emptySet());
changed = true;
} else if (dto.getSystemTags().size() != ruleDef.tags().size() ||
!dto.getSystemTags().containsAll(ruleDef.tags())) {
return changed;
}
+ private void updateDeprecatedKeys(RulesDefinition.Rule ruleDef, RuleDefinitionDto rule,
+ Map<Integer, Set<SingleDeprecatedRuleKey>> existingDeprecatedKeysById, DbSession dbSession) {
+
+ Set<SingleDeprecatedRuleKey> deprecatedRuleKeysFromDefinition = SingleDeprecatedRuleKey.from(ruleDef);
+ Set<SingleDeprecatedRuleKey> deprecatedRuleKeysFromDB = existingDeprecatedKeysById.getOrDefault(rule.getId(), emptySet());
+
+ // DeprecatedKeys that must be deleted
+ List<String> uuidsToBeDeleted = difference(deprecatedRuleKeysFromDB, deprecatedRuleKeysFromDefinition).stream()
+ .map(SingleDeprecatedRuleKey::getUuid)
+ .collect(MoreCollectors.toList());
+
+ dbClient.ruleDao().deleteDeprecatedRuleKeys(dbSession, uuidsToBeDeleted);
+
+ // DeprecatedKeys that must be created
+ Sets.SetView<SingleDeprecatedRuleKey> deprecatedRuleKeysToBeCreated = difference(deprecatedRuleKeysFromDefinition, deprecatedRuleKeysFromDB);
+
+ deprecatedRuleKeysToBeCreated
+ .forEach(r -> dbClient.ruleDao().insert(dbSession, new DeprecatedRuleKeyDto()
+ .setUuid(uuidFactory.create())
+ .setRuleId(rule.getId())
+ .setOldRepositoryKey(r.getOldRepositoryKey())
+ .setOldRuleKey(r.getOldRuleKey())
+ .setCreatedAt(system2.now())
+ )
+ );
+ }
+
private List<RuleDefinitionDto> processRemainingDbRules(Collection<RuleDefinitionDto> existingRules, DbSession session) {
// custom rules check status of template, so they must be processed at the end
List<RuleDefinitionDto> customRules = newArrayList();
private void removeRule(DbSession session, List<RuleDefinitionDto> removedRules, RuleDefinitionDto rule) {
LOG.info(format("Disable rule %s", rule.getKey()));
rule.setStatus(RuleStatus.REMOVED);
- rule.setSystemTags(Collections.emptySet());
+ rule.setSystemTags(emptySet());
update(session, rule);
// FIXME resetting the tags for all organizations must be handled a different way
// rule.setTags(Collections.emptySet());
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2018 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;
+
+import java.util.Objects;
+import java.util.Set;
+import javax.annotation.CheckForNull;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.Immutable;
+import org.sonar.api.rule.RuleKey;
+import org.sonar.api.server.rule.RulesDefinition;
+import org.sonar.core.util.stream.MoreCollectors;
+import org.sonar.db.rule.DeprecatedRuleKeyDto;
+
+@Immutable
+class SingleDeprecatedRuleKey {
+ private String oldRuleKey;
+ private String oldRepositoryKey;
+ private String newRuleKey;
+ private String newRepositoryKey;
+ private String uuid;
+ private Integer ruleId;
+
+ /**
+ * static methods {@link #from(RulesDefinition.Rule)} and {@link #from(DeprecatedRuleKeyDto)} must be used
+ */
+ private SingleDeprecatedRuleKey() {
+ // empty
+ }
+
+ public static Set<SingleDeprecatedRuleKey> from(RulesDefinition.Rule rule) {
+ return rule.deprecatedRuleKeys().stream()
+ .map(r -> new SingleDeprecatedRuleKey()
+ .setNewRepositoryKey(rule.repository().key())
+ .setNewRuleKey(rule.key())
+ .setOldRepositoryKey(r.repository())
+ .setOldRuleKey(r.rule()))
+ .collect(MoreCollectors.toSet(rule.deprecatedRuleKeys().size()));
+ }
+
+ public static SingleDeprecatedRuleKey from(DeprecatedRuleKeyDto rule) {
+ return new SingleDeprecatedRuleKey()
+ .setUuid(rule.getUuid())
+ .setRuleId(rule.getRuleId())
+ .setNewRepositoryKey(rule.getNewRepositoryKey())
+ .setNewRuleKey(rule.getNewRuleKey())
+ .setOldRepositoryKey(rule.getOldRepositoryKey())
+ .setOldRuleKey(rule.getOldRuleKey());
+ }
+
+ public String getOldRuleKey() {
+ return oldRuleKey;
+ }
+
+ public String getOldRepositoryKey() {
+ return oldRepositoryKey;
+ }
+
+ public RuleKey getOldRuleKeyAsRuleKey() {
+ return RuleKey.of(oldRepositoryKey, oldRuleKey);
+ }
+
+ @CheckForNull
+ public String getNewRuleKey() {
+ return newRuleKey;
+ }
+
+ @CheckForNull
+ public String getNewRepositoryKey() {
+ return newRepositoryKey;
+ }
+
+ @CheckForNull
+ public String getUuid() {
+ return uuid;
+ }
+
+ @CheckForNull
+ public Integer getRuleId() {
+ return ruleId;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (!(o instanceof SingleDeprecatedRuleKey)) {
+ return false;
+ }
+ SingleDeprecatedRuleKey that = (SingleDeprecatedRuleKey) o;
+ return Objects.equals(oldRuleKey, that.oldRuleKey) &&
+ Objects.equals(oldRepositoryKey, that.oldRepositoryKey) &&
+ Objects.equals(newRuleKey, that.newRuleKey) &&
+ Objects.equals(newRepositoryKey, that.newRepositoryKey);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(oldRuleKey, oldRepositoryKey, newRuleKey, newRepositoryKey);
+ }
+
+ private SingleDeprecatedRuleKey setRuleId(Integer ruleId) {
+ this.ruleId = ruleId;
+ return this;
+ }
+
+ private SingleDeprecatedRuleKey setUuid(String uuid) {
+ this.uuid = uuid;
+ return this;
+ }
+
+ private SingleDeprecatedRuleKey setOldRuleKey(String oldRuleKey) {
+ this.oldRuleKey = oldRuleKey;
+ return this;
+ }
+
+ private SingleDeprecatedRuleKey setOldRepositoryKey(String oldRepositoryKey) {
+ this.oldRepositoryKey = oldRepositoryKey;
+ return this;
+ }
+
+ private SingleDeprecatedRuleKey setNewRuleKey(@Nullable String newRuleKey) {
+ this.newRuleKey = newRuleKey;
+ return this;
+ }
+
+ private SingleDeprecatedRuleKey setNewRepositoryKey(@Nullable String newRepositoryKey) {
+ this.newRepositoryKey = newRepositoryKey;
+ return this;
+ }
+}
import java.util.Date;
import java.util.List;
+import java.util.Set;
import java.util.stream.IntStream;
import org.junit.Before;
import org.junit.Test;
import org.sonar.api.utils.System2;
import org.sonar.api.utils.log.LogTester;
import org.sonar.api.utils.log.LoggerLevel;
+import org.sonar.core.util.UuidFactory;
+import org.sonar.core.util.UuidFactoryFast;
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.rule.DeprecatedRuleKeyDto;
import org.sonar.db.rule.RuleDefinitionDto;
import org.sonar.db.rule.RuleDto;
import org.sonar.db.rule.RuleDto.Scope;
import static org.mockito.Mockito.when;
import static org.sonar.api.rule.Severity.BLOCKER;
import static org.sonar.api.rule.Severity.INFO;
+import static org.sonar.api.server.rule.RulesDefinition.*;
public class RegisterRulesTest {
private RuleIndex ruleIndex;
private OrganizationDto defaultOrganization;
private OrganizationFlags organizationFlags = TestOrganizationFlags.standalone();
+ private UuidFactory uuidFactory = UuidFactoryFast.getInstance();
@Before
public void before() {
// register one rule
execute(context -> {
- RulesDefinition.NewRepository repo = context.createRepository("fake", "java");
+ NewRepository repo = context.createRepository("fake", "java");
repo.createRule(ruleKey)
.setName(randomAlphanumeric(5))
.setHtmlDescription(randomAlphanumeric(20));
// register many rules
execute(context -> {
- RulesDefinition.NewRepository repo = context.createRepository("fake", "java");
+ NewRepository repo = context.createRepository("fake", "java");
IntStream.range(0, numberOfRules)
.mapToObj(i -> "rule-" + i)
.forEach(ruleKey -> repo.createRule(ruleKey)
@Test
public void add_new_tag() {
- execute(new RulesDefinition() {
- @Override
- public void define(RulesDefinition.Context context) {
- RulesDefinition.NewRepository repo = context.createRepository("fake", "java");
- repo.createRule("rule1")
- .setName("Rule One")
- .setHtmlDescription("Description of Rule One")
- .setTags("tag1");
- repo.done();
- }
+ execute((RulesDefinition) context -> {
+ NewRepository repo = context.createRepository("fake", "java");
+ repo.createRule("rule1")
+ .setName("Rule One")
+ .setHtmlDescription("Description of Rule One")
+ .setTags("tag1");
+ repo.done();
});
OrganizationDto defaultOrganization = dbTester.getDefaultOrganization();
RuleDto rule = dbClient.ruleDao().selectOrFailByKey(dbTester.getSession(), defaultOrganization, RULE_KEY1);
assertThat(rule.getSystemTags()).containsOnly("tag1");
- execute(new RulesDefinition() {
- @Override
- public void define(RulesDefinition.Context context) {
- RulesDefinition.NewRepository repo = context.createRepository("fake", "java");
- repo.createRule("rule1")
- .setName("Rule One")
- .setHtmlDescription("Description of Rule One")
- .setTags("tag1", "tag2");
- repo.done();
- }
+ execute((RulesDefinition) context -> {
+ NewRepository repo = context.createRepository("fake", "java");
+ repo.createRule("rule1")
+ .setName("Rule One")
+ .setHtmlDescription("Description of Rule One")
+ .setTags("tag1", "tag2");
+ repo.done();
});
rule = dbClient.ruleDao().selectOrFailByKey(dbTester.getSession(), defaultOrganization, RULE_KEY1);
@Test
public void update_only_rule_name() {
when(system.now()).thenReturn(DATE1.getTime());
- execute(new RulesDefinition() {
- @Override
- public void define(Context context) {
- NewRepository repo = context.createRepository("fake", "java");
- repo.createRule("rule")
- .setName("Name1")
- .setHtmlDescription("Description");
- repo.done();
- }
+ execute((RulesDefinition) context -> {
+ NewRepository repo = context.createRepository("fake", "java");
+ repo.createRule("rule")
+ .setName("Name1")
+ .setHtmlDescription("Description");
+ repo.done();
});
when(system.now()).thenReturn(DATE2.getTime());
- execute(new RulesDefinition() {
- @Override
- public void define(Context context) {
- NewRepository repo = context.createRepository("fake", "java");
- repo.createRule("rule")
- .setName("Name2")
- .setHtmlDescription("Description");
- repo.done();
- }
+ execute((RulesDefinition) context -> {
+ NewRepository repo = context.createRepository("fake", "java");
+ repo.createRule("rule")
+ .setName("Name2")
+ .setHtmlDescription("Description");
+ repo.done();
});
// rule1 has been updated
@Test
public void update_only_rule_description() {
when(system.now()).thenReturn(DATE1.getTime());
- execute(new RulesDefinition() {
- @Override
- public void define(Context context) {
- NewRepository repo = context.createRepository("fake", "java");
- repo.createRule("rule")
- .setName("Name")
- .setHtmlDescription("Desc1");
- repo.done();
- }
+ execute((RulesDefinition) context -> {
+ NewRepository repo = context.createRepository("fake", "java");
+ repo.createRule("rule")
+ .setName("Name")
+ .setHtmlDescription("Desc1");
+ repo.done();
});
when(system.now()).thenReturn(DATE2.getTime());
- execute(new RulesDefinition() {
- @Override
- public void define(Context context) {
- NewRepository repo = context.createRepository("fake", "java");
- repo.createRule("rule")
- .setName("Name")
- .setHtmlDescription("Desc2");
- repo.done();
- }
+ execute((RulesDefinition) context -> {
+ NewRepository repo = context.createRepository("fake", "java");
+ repo.createRule("rule")
+ .setName("Name")
+ .setHtmlDescription("Desc2");
+ repo.done();
});
// rule1 has been updated
when(system.now()).thenReturn(DATE2.getTime());
execute(new FakeRepositoryV1());
- String organizationUuid = dbTester.getDefaultOrganization().getUuid();
RuleDto rule1 = dbClient.ruleDao().selectOrFailByKey(dbTester.getSession(), defaultOrganization, RULE_KEY1);
assertThat(rule1.getCreatedAt()).isEqualTo(DATE1.getTime());
assertThat(rule1.getUpdatedAt()).isEqualTo(DATE1.getTime());
assertThat(dbClient.ruleDao().selectAllDefinitions(dbTester.getSession())).hasSize(2);
assertThat(esTester.getIds(RuleIndexDefinition.INDEX_TYPE_RULE)).containsOnly(RULE_KEY1.toString(), RULE_KEY2.toString());
- String organizationUuid = dbTester.getDefaultOrganization().getUuid();
RuleDto rule2 = dbClient.ruleDao().selectOrFailByKey(dbTester.getSession(), defaultOrganization, RULE_KEY2);
assertThat(rule2.getStatus()).isEqualTo(RuleStatus.READY);
assertThat(logTester.logs(LoggerLevel.INFO)).contains("Template rule test:rule1 will not be imported, because organizations are enabled.");
}
+ @Test
+ public void rules_that_deprecate_previous_rule_must_be_recorded() {
+ execute(context -> {
+ NewRepository repo = context.createRepository("fake", "java");
+ repo.createRule("rule1")
+ .setName("One")
+ .setHtmlDescription("Description of One")
+ .setSeverity(BLOCKER)
+ .setInternalKey("config1")
+ .setTags("tag1", "tag2", "tag3")
+ .setType(RuleType.CODE_SMELL)
+ .setStatus(RuleStatus.BETA);
+ repo.done();
+ });
+
+ execute(context -> {
+ NewRepository repo = context.createRepository("fake", "java");
+ repo.createRule("newKey")
+ .setName("One")
+ .setHtmlDescription("Description of One")
+ .setSeverity(BLOCKER)
+ .setInternalKey("config1")
+ .setTags("tag1", "tag2", "tag3")
+ .setType(RuleType.CODE_SMELL)
+ .setStatus(RuleStatus.BETA)
+ .addDeprecatedRuleKey("fake", "rule1")
+ .addDeprecatedRuleKey("fake", "rule2");
+ repo.done();
+ });
+
+ List<RuleDefinitionDto> rules = dbClient.ruleDao().selectAllDefinitions(dbTester.getSession());
+ Set<DeprecatedRuleKeyDto> deprecatedRuleKeys = dbClient.ruleDao().selectAllDeprecatedRuleKeys(dbTester.getSession());
+ //assertThat(rules).hasSize(1); FIXME this must be true when renaming is done
+ assertThat(deprecatedRuleKeys).hasSize(2);
+ }
+
+ @Test
+ public void rules_that_remove_deprecated_key_must_remove_records() {
+ execute(context -> {
+ NewRepository repo = context.createRepository("fake", "java");
+ repo.createRule("rule1")
+ .setName("One")
+ .setHtmlDescription("Description of One")
+ .setSeverity(BLOCKER)
+ .setInternalKey("config1")
+ .setTags("tag1", "tag2", "tag3")
+ .setType(RuleType.CODE_SMELL)
+ .setStatus(RuleStatus.BETA);
+ repo.done();
+ });
+
+ execute(context -> {
+ NewRepository repo = context.createRepository("fake", "java");
+ repo.createRule("newKey")
+ .setName("One")
+ .setHtmlDescription("Description of One")
+ .setSeverity(BLOCKER)
+ .setInternalKey("config1")
+ .setTags("tag1", "tag2", "tag3")
+ .setType(RuleType.CODE_SMELL)
+ .setStatus(RuleStatus.BETA)
+ .addDeprecatedRuleKey("fake", "rule1")
+ .addDeprecatedRuleKey("fake", "rule2");
+ repo.done();
+ });
+
+ //assertThat(dbClient.ruleDao().selectAllDefinitions(dbTester.getSession())).hasSize(1); FIXME this must be true when renaming is done
+ Set<DeprecatedRuleKeyDto> deprecatedRuleKeys = dbClient.ruleDao().selectAllDeprecatedRuleKeys(dbTester.getSession());
+ assertThat(deprecatedRuleKeys).hasSize(2);
+
+ execute(context -> {
+ NewRepository repo = context.createRepository("fake", "java");
+ repo.createRule("newKey")
+ .setName("One")
+ .setHtmlDescription("Description of One")
+ .setSeverity(BLOCKER)
+ .setInternalKey("config1")
+ .setTags("tag1", "tag2", "tag3")
+ .setType(RuleType.CODE_SMELL)
+ .setStatus(RuleStatus.BETA);
+ repo.done();
+ });
+
+ //assertThat(dbClient.ruleDao().selectAllDefinitions(dbTester.getSession())).hasSize(1); FIXME this must be true when renaming is done
+ deprecatedRuleKeys = dbClient.ruleDao().selectAllDeprecatedRuleKeys(dbTester.getSession());
+ assertThat(deprecatedRuleKeys).hasSize(0);
+ }
+
private void execute(RulesDefinition... defs) {
ServerPluginRepository pluginRepository = mock(ServerPluginRepository.class);
when(pluginRepository.getPluginKey(any(RulesDefinition.class))).thenReturn(FAKE_PLUGIN_KEY);
when(languages.get("java")).thenReturn(mock(Language.class));
reset(webServerRuleFinder);
- RegisterRules task = new RegisterRules(loader, qProfileRules, dbClient, ruleIndexer, activeRuleIndexer, languages, system, organizationFlags, webServerRuleFinder);
+ RegisterRules task = new RegisterRules(loader, qProfileRules, dbClient, ruleIndexer, activeRuleIndexer,
+ languages, system, organizationFlags, webServerRuleFinder, uuidFactory);
task.start();
// Execute a commit to refresh session state as the task is using its own session
dbTester.getSession().commit();
static class RepositoryWithOneTemplateRule implements RulesDefinition {
@Override
public void define(Context context) {
- RulesDefinition.NewRepository repo = context.createRepository("test", "java");
+ NewRepository repo = context.createRepository("test", "java");
repo.createRule("rule1")
.setName("Rule One")
.setHtmlDescription("Description of Rule One")
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2018 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;
+
+import com.google.common.collect.ImmutableSet;
+import java.util.Set;
+import org.assertj.core.groups.Tuple;
+import org.junit.Test;
+import org.sonar.api.rule.RuleKey;
+import org.sonar.api.server.rule.RulesDefinition;
+import org.sonar.core.util.stream.MoreCollectors;
+import org.sonar.db.rule.DeprecatedRuleKeyDto;
+
+import static org.apache.commons.lang.RandomStringUtils.randomAlphanumeric;
+import static org.apache.commons.lang.math.RandomUtils.nextInt;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.groups.Tuple.tuple;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class SingleDeprecatedRuleKeyTest {
+
+ @Test
+ public void test_creation_from_DeprecatedRuleKeyDto() {
+ // Creation from DeprecatedRuleKeyDto
+ DeprecatedRuleKeyDto deprecatedRuleKeyDto = new DeprecatedRuleKeyDto()
+ .setOldRuleKey(randomAlphanumeric(50))
+ .setOldRepositoryKey(randomAlphanumeric(50))
+ .setRuleId(nextInt(1000))
+ .setUuid(randomAlphanumeric(40));
+
+ SingleDeprecatedRuleKey singleDeprecatedRuleKey = SingleDeprecatedRuleKey.from(deprecatedRuleKeyDto);
+
+ assertThat(singleDeprecatedRuleKey.getOldRepositoryKey()).isEqualTo(deprecatedRuleKeyDto.getOldRepositoryKey());
+ assertThat(singleDeprecatedRuleKey.getOldRuleKey()).isEqualTo(deprecatedRuleKeyDto.getOldRuleKey());
+ assertThat(singleDeprecatedRuleKey.getNewRepositoryKey()).isEqualTo(deprecatedRuleKeyDto.getNewRepositoryKey());
+ assertThat(singleDeprecatedRuleKey.getNewRuleKey()).isEqualTo(deprecatedRuleKeyDto.getNewRuleKey());
+ assertThat(singleDeprecatedRuleKey.getUuid()).isEqualTo(deprecatedRuleKeyDto.getUuid());
+ assertThat(singleDeprecatedRuleKey.getRuleId()).isEqualTo(deprecatedRuleKeyDto.getRuleId());
+ assertThat(singleDeprecatedRuleKey.getOldRuleKeyAsRuleKey())
+ .isEqualTo(RuleKey.of(deprecatedRuleKeyDto.getOldRepositoryKey(), deprecatedRuleKeyDto.getOldRuleKey()));
+ }
+
+ @Test
+ public void test_creation_from_RulesDefinitionRule() {
+ // Creation from RulesDefinition.Rule
+ ImmutableSet<RuleKey> deprecatedRuleKeys = ImmutableSet.of(
+ RuleKey.of(randomAlphanumeric(50), randomAlphanumeric(50)),
+ RuleKey.of(randomAlphanumeric(50), randomAlphanumeric(50)),
+ RuleKey.of(randomAlphanumeric(50), randomAlphanumeric(50))
+ );
+
+ RulesDefinition.Repository repository = mock(RulesDefinition.Repository.class);
+ when(repository.key()).thenReturn(randomAlphanumeric(50));
+
+ RulesDefinition.Rule rule = mock(RulesDefinition.Rule.class);
+ when(rule.key()).thenReturn(randomAlphanumeric(50));
+ when(rule.deprecatedRuleKeys()).thenReturn(deprecatedRuleKeys);
+ when(rule.repository()).thenReturn(repository);
+
+ Set<SingleDeprecatedRuleKey> singleDeprecatedRuleKeys = SingleDeprecatedRuleKey.from(rule);
+ assertThat(singleDeprecatedRuleKeys).hasSize(deprecatedRuleKeys.size());
+ assertThat(singleDeprecatedRuleKeys)
+ .extracting(SingleDeprecatedRuleKey::getUuid, SingleDeprecatedRuleKey::getOldRepositoryKey, SingleDeprecatedRuleKey::getOldRuleKey,
+ SingleDeprecatedRuleKey::getNewRepositoryKey, SingleDeprecatedRuleKey::getNewRuleKey, SingleDeprecatedRuleKey::getOldRuleKeyAsRuleKey)
+ .containsExactlyInAnyOrder(
+ deprecatedRuleKeys.stream().map(
+ r -> tuple(null, r.repository(), r.rule(), rule.repository().key(), rule.key(), RuleKey.of(r.repository(), r.rule()))
+ ).collect(MoreCollectors.toArrayList(deprecatedRuleKeys.size())).toArray(new Tuple[deprecatedRuleKeys.size()])
+ );
+ }
+
+ @Test
+ public void test_equality() {
+ DeprecatedRuleKeyDto deprecatedRuleKeyDto1 = new DeprecatedRuleKeyDto()
+ .setOldRuleKey(randomAlphanumeric(50))
+ .setOldRepositoryKey(randomAlphanumeric(50))
+ .setUuid(randomAlphanumeric(40))
+ .setRuleId(1);
+
+ DeprecatedRuleKeyDto deprecatedRuleKeyDto1WithoutUuid = new DeprecatedRuleKeyDto()
+ .setOldRuleKey(deprecatedRuleKeyDto1.getOldRuleKey())
+ .setOldRepositoryKey(deprecatedRuleKeyDto1.getOldRepositoryKey());
+
+ DeprecatedRuleKeyDto deprecatedRuleKeyDto2 = new DeprecatedRuleKeyDto()
+ .setOldRuleKey(randomAlphanumeric(50))
+ .setOldRepositoryKey(randomAlphanumeric(50))
+ .setUuid(randomAlphanumeric(40));
+
+ SingleDeprecatedRuleKey singleDeprecatedRuleKey1 = SingleDeprecatedRuleKey.from(deprecatedRuleKeyDto1);
+ SingleDeprecatedRuleKey singleDeprecatedRuleKey2 = SingleDeprecatedRuleKey.from(deprecatedRuleKeyDto2);
+
+ assertThat(singleDeprecatedRuleKey1).isEqualTo(singleDeprecatedRuleKey1);
+ assertThat(singleDeprecatedRuleKey1).isEqualTo(SingleDeprecatedRuleKey.from(deprecatedRuleKeyDto1));
+ assertThat(singleDeprecatedRuleKey1).isEqualTo(SingleDeprecatedRuleKey.from(deprecatedRuleKeyDto1WithoutUuid));
+ assertThat(singleDeprecatedRuleKey2).isEqualTo(SingleDeprecatedRuleKey.from(deprecatedRuleKeyDto2));
+
+ assertThat(singleDeprecatedRuleKey1.hashCode()).isEqualTo(singleDeprecatedRuleKey1.hashCode());
+ assertThat(singleDeprecatedRuleKey1.hashCode()).isEqualTo(SingleDeprecatedRuleKey.from(deprecatedRuleKeyDto1).hashCode());
+ assertThat(singleDeprecatedRuleKey1.hashCode()).isEqualTo(SingleDeprecatedRuleKey.from(deprecatedRuleKeyDto1WithoutUuid).hashCode());
+ assertThat(singleDeprecatedRuleKey2.hashCode()).isEqualTo(SingleDeprecatedRuleKey.from(deprecatedRuleKeyDto2).hashCode());
+
+ assertThat(singleDeprecatedRuleKey1).isNotEqualTo(null);
+ assertThat(singleDeprecatedRuleKey1).isNotEqualTo("");
+ assertThat(singleDeprecatedRuleKey1).isNotEqualTo(singleDeprecatedRuleKey2);
+ assertThat(singleDeprecatedRuleKey2).isNotEqualTo(singleDeprecatedRuleKey1);
+
+ assertThat(singleDeprecatedRuleKey1.hashCode()).isNotEqualTo(singleDeprecatedRuleKey2.hashCode());
+ assertThat(singleDeprecatedRuleKey2.hashCode()).isNotEqualTo(singleDeprecatedRuleKey1.hashCode());
+ }
+}
projects / sonarqube.git / commitdiff