+++ /dev/null
-/*
- * SonarQube, open source software quality management tool.
- * Copyright (C) 2008-2014 SonarSource
- * mailto:contact AT sonarsource DOT com
- *
- * SonarQube 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.
- *
- * SonarQube 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.api;
-
-/**
- * @since 4.4
- */
-public interface DaoComponent {
-}
--- /dev/null
+/*
+ * SonarQube, open source software quality management tool.
+ * Copyright (C) 2008-2014 SonarSource
+ * mailto:contact AT sonarsource DOT com
+ *
+ * SonarQube 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.
+ *
+ * SonarQube 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.core.persistence;
+
+/**
+ * @since 4.4
+ */
+public interface DaoComponent {
+}
import org.apache.commons.lang.StringUtils;
import org.apache.ibatis.session.SqlSession;
import org.sonar.api.BatchComponent;
-import org.sonar.api.DaoComponent;
+import org.sonar.core.persistence.DaoComponent;
import org.sonar.api.ServerComponent;
import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
import com.google.common.base.Preconditions;
import org.apache.ibatis.session.SqlSession;
-import org.sonar.api.DaoComponent;
+import org.sonar.core.persistence.DaoComponent;
import org.sonar.api.ServerComponent;
import org.sonar.core.component.ComponentDto;
import org.sonar.core.persistence.DbSession;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import org.apache.ibatis.session.SqlSession;
-import org.sonar.api.DaoComponent;
+import org.sonar.core.persistence.DaoComponent;
import org.sonar.api.component.Component;
import org.sonar.core.component.ComponentDto;
import org.sonar.core.persistence.MyBatis;
import com.google.common.collect.Lists;
import org.apache.ibatis.session.SqlSession;
import org.sonar.api.BatchComponent;
-import org.sonar.api.DaoComponent;
+import org.sonar.core.persistence.DaoComponent;
import org.sonar.api.ServerComponent;
import org.sonar.core.persistence.MyBatis;
import org.apache.ibatis.session.SqlSession;
import org.sonar.api.BatchComponent;
-import org.sonar.api.DaoComponent;
+import org.sonar.core.persistence.DaoComponent;
import org.sonar.api.ServerComponent;
import org.sonar.core.persistence.MyBatis;
import com.google.common.annotations.VisibleForTesting;
import org.apache.ibatis.session.SqlSession;
-import org.sonar.api.DaoComponent;
+import org.sonar.core.persistence.DaoComponent;
import org.sonar.api.ServerComponent;
import org.sonar.api.utils.System2;
import org.sonar.core.component.ComponentDto;
DbSession session = dbClient.openSession(false);
try {
- ComponentDto component = dbClient.getDao(ComponentDao.class).getByKey(fileKey, session);
+ ComponentDto component = dbClient.componentDao().getByKey(fileKey, session);
if (component == null) {
throw new NotFoundException(String.format("Component '%s' does not exists.", fileKey));
}
}
private void appendComponent(JsonWriter json, ComponentDto component, UserSession userSession, DbSession session) {
- List<PropertyDto> propertyDtos = dbClient.getDao(PropertiesDao.class).selectByQuery(PropertyQuery.builder()
+ List<PropertyDto> propertyDtos = dbClient.propertiesDao().selectByQuery(PropertyQuery.builder()
.setKey("favourite")
.setComponentId(component.getId())
.setUserId(userSession.userId())
private void appendMeasures(JsonWriter json, String fileKey, DbSession session) {
json.name("measures").beginObject();
- List<MeasureDto> measures = dbClient.getDao(MeasureDao.class).findByComponentKeyAndMetricKeys(fileKey,
+ List<MeasureDto> measures = dbClient.measureDao().findByComponentKeyAndMetricKeys(fileKey,
newArrayList(CoreMetrics.NCLOC_KEY, CoreMetrics.COVERAGE_KEY, CoreMetrics.DUPLICATED_LINES_DENSITY_KEY, CoreMetrics.TECHNICAL_DEBT_KEY, CoreMetrics.VIOLATIONS_KEY,
CoreMetrics.BLOCKER_VIOLATIONS_KEY, CoreMetrics.MAJOR_VIOLATIONS_KEY, CoreMetrics.MAJOR_VIOLATIONS_KEY, CoreMetrics.MINOR_VIOLATIONS_KEY, CoreMetrics.INFO_VIOLATIONS_KEY),
session
private void appendPeriods(JsonWriter json, Long projectId, DbSession session) {
json.name("periods").beginArray();
- SnapshotDto snapshotDto = dbClient.getDao(ResourceDao.class).getLastSnapshotByResourceId(projectId, session);
+ SnapshotDto snapshotDto = dbClient.resourceDao().getLastSnapshotByResourceId(projectId, session);
if (snapshotDto != null) {
for (int i = 1; i <= 5; i++) {
String mode = snapshotDto.getPeriodMode(i);
@CheckForNull
private Component componentById(@Nullable Long componentId, DbSession session) {
if (componentId != null) {
- return dbClient.getDao(ComponentDao.class).getById(componentId, session);
+ return dbClient.componentDao().getById(componentId, session);
}
return null;
}
package org.sonar.server.db;
import com.google.common.base.Preconditions;
-import org.sonar.api.DaoComponent;
+import org.sonar.core.persistence.DaoComponent;
import org.sonar.api.utils.System2;
import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.Dto;
*/
package org.sonar.server.db;
-import org.sonar.api.DaoComponent;
+import com.google.common.collect.Maps;
import org.sonar.api.ServerComponent;
+import org.sonar.core.persistence.DaoComponent;
import org.sonar.core.persistence.Database;
import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
+import org.sonar.core.properties.PropertiesDao;
import org.sonar.core.qualityprofile.db.QualityProfileDao;
+import org.sonar.core.resource.ResourceDao;
+import org.sonar.core.technicaldebt.db.CharacteristicDao;
+import org.sonar.core.technicaldebt.db.RequirementDao;
+import org.sonar.core.template.LoadedTemplateDao;
+import org.sonar.server.component.persistence.ComponentDao;
+import org.sonar.server.measure.persistence.MeasureDao;
import org.sonar.server.qualityprofile.persistence.ActiveRuleDao;
import org.sonar.server.rule2.persistence.RuleDao;
-import java.util.HashMap;
import java.util.Map;
/**
private final Database db;
private final MyBatis myBatis;
- private final Map<Class<?>, DaoComponent> daoComponents;
+ private final RuleDao ruleDao;
+ private final ActiveRuleDao activeRuleDao;
+ private final QualityProfileDao qualityProfileDao;
+ private final CharacteristicDao debtCharacteristicDao;
+ private final LoadedTemplateDao loadedTemplateDao;
+ private final PropertiesDao propertiesDao;
+ private final ComponentDao componentDao;
+ private final ResourceDao resourceDao;
+ private final MeasureDao measureDao;
+ private final RequirementDao debtRequirementDao;
public DbClient(Database db, MyBatis myBatis, DaoComponent... daoComponents) {
this.db = db;
this.myBatis = myBatis;
- this.daoComponents = new HashMap<Class<?>, DaoComponent>();
- for(DaoComponent daoComponent : daoComponents){
- this.daoComponents.put(daoComponent.getClass(), daoComponent);
+ Map<Class, DaoComponent> map = Maps.newHashMap();
+ for (DaoComponent daoComponent : daoComponents) {
+ map.put(daoComponent.getClass(), daoComponent);
}
+ ruleDao = getDao(map, RuleDao.class);
+ activeRuleDao = getDao(map, ActiveRuleDao.class);
+ debtCharacteristicDao = getDao(map, CharacteristicDao.class);
+ qualityProfileDao = getDao(map, QualityProfileDao.class);
+ loadedTemplateDao = getDao(map, LoadedTemplateDao.class);
+ propertiesDao = getDao(map, PropertiesDao.class);
+ componentDao = getDao(map, ComponentDao.class);
+ resourceDao = getDao(map, ResourceDao.class);
+ measureDao = getDao(map, MeasureDao.class);
+ debtRequirementDao = getDao(map, RequirementDao.class);
}
public Database database() {
return myBatis.openSession(batch);
}
- public <K> K getDao(Class<K> clazz){
- return (K) this.daoComponents.get(clazz);
- }
-
public RuleDao ruleDao() {
- return this.getDao(RuleDao.class);
+ return ruleDao;
}
public ActiveRuleDao activeRuleDao() {
- return this.getDao(ActiveRuleDao.class);
+ return activeRuleDao;
}
public QualityProfileDao qualityProfileDao() {
- return this.getDao(QualityProfileDao.class);
+ return qualityProfileDao;
+ }
+
+ public CharacteristicDao debtCharacteristicDao() {
+ return debtCharacteristicDao;
+ }
+
+ public LoadedTemplateDao loadedTemplateDao() {
+ return loadedTemplateDao;
+ }
+
+ public PropertiesDao propertiesDao() {
+ return propertiesDao;
+ }
+
+ public ComponentDao componentDao() {
+ return componentDao;
+ }
+
+ public ResourceDao resourceDao() {
+ return resourceDao;
+ }
+
+ public MeasureDao measureDao() {
+ return measureDao;
+ }
+
+ public RequirementDao debtRequirementDao() {
+ return debtRequirementDao;
+ }
+
+ private <K> K getDao(Map<Class, DaoComponent> map, Class<K> clazz) {
+ return (K) map.get(clazz);
}
}
import com.google.common.collect.Iterables;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang.ObjectUtils;
-import org.apache.ibatis.session.SqlSession;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.sonar.api.ServerComponent;
import org.sonar.core.permission.GlobalPermissions;
import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
-import org.sonar.core.rule.RuleDao;
import org.sonar.core.rule.RuleDto;
-import org.sonar.core.technicaldebt.db.CharacteristicDao;
import org.sonar.core.technicaldebt.db.CharacteristicDto;
+import org.sonar.server.db.DbClient;
import org.sonar.server.debt.DebtModelXMLExporter.DebtModel;
import org.sonar.server.debt.DebtModelXMLExporter.RuleDebt;
import org.sonar.server.exceptions.NotFoundException;
import org.sonar.server.rule.RuleDefinitionsLoader;
import org.sonar.server.rule.RuleOperations;
-import org.sonar.server.rule.RuleRegistry;
import org.sonar.server.user.UserSession;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
-
import java.io.Reader;
import java.util.Date;
import java.util.List;
private static final Logger LOG = LoggerFactory.getLogger(DebtModelBackup.class);
- private final MyBatis mybatis;
- private final CharacteristicDao dao;
- private final RuleDao ruleDao;
+ private final DbClient dbClient;
private final DebtModelOperations debtModelOperations;
private final RuleOperations ruleOperations;
private final DebtModelPluginRepository debtModelPluginRepository;
private final DebtCharacteristicsXMLImporter characteristicsXMLImporter;
private final DebtRulesXMLImporter rulesXMLImporter;
private final DebtModelXMLExporter debtModelXMLExporter;
- private final RuleRegistry ruleRegistry;
private final RuleDefinitionsLoader defLoader;
private final System2 system2;
- public DebtModelBackup(MyBatis mybatis, CharacteristicDao dao, RuleDao ruleDao, DebtModelOperations debtModelOperations, RuleOperations ruleOperations,
+ public DebtModelBackup(DbClient dbClient, DebtModelOperations debtModelOperations, RuleOperations ruleOperations,
DebtModelPluginRepository debtModelPluginRepository, DebtCharacteristicsXMLImporter characteristicsXMLImporter, DebtRulesXMLImporter rulesXMLImporter,
- DebtModelXMLExporter debtModelXMLExporter, RuleRegistry ruleRegistry, RuleDefinitionsLoader defLoader) {
- this(mybatis, dao, ruleDao, debtModelOperations, ruleOperations, debtModelPluginRepository, characteristicsXMLImporter, rulesXMLImporter, debtModelXMLExporter, ruleRegistry,
+ DebtModelXMLExporter debtModelXMLExporter, RuleDefinitionsLoader defLoader) {
+ this(dbClient, debtModelOperations, ruleOperations, debtModelPluginRepository, characteristicsXMLImporter, rulesXMLImporter, debtModelXMLExporter,
defLoader, System2.INSTANCE);
}
@VisibleForTesting
- DebtModelBackup(MyBatis mybatis, CharacteristicDao dao, RuleDao ruleDao, DebtModelOperations debtModelOperations, RuleOperations ruleOperations,
+ DebtModelBackup(DbClient dbClient, DebtModelOperations debtModelOperations, RuleOperations ruleOperations,
DebtModelPluginRepository debtModelPluginRepository, DebtCharacteristicsXMLImporter characteristicsXMLImporter, DebtRulesXMLImporter rulesXMLImporter,
- DebtModelXMLExporter debtModelXMLExporter, RuleRegistry ruleRegistry, RuleDefinitionsLoader defLoader, System2 system2) {
- this.mybatis = mybatis;
- this.dao = dao;
- this.ruleDao = ruleDao;
+ DebtModelXMLExporter debtModelXMLExporter, RuleDefinitionsLoader defLoader, System2 system2) {
+ this.dbClient = dbClient;
this.debtModelOperations = debtModelOperations;
this.ruleOperations = ruleOperations;
this.debtModelPluginRepository = debtModelPluginRepository;
this.characteristicsXMLImporter = characteristicsXMLImporter;
this.rulesXMLImporter = rulesXMLImporter;
this.debtModelXMLExporter = debtModelXMLExporter;
- this.ruleRegistry = ruleRegistry;
this.defLoader = defLoader;
this.system2 = system2;
}
private String backupFromLanguage(@Nullable String languageKey) {
checkPermission();
- SqlSession session = mybatis.openSession(false);
+ DbSession session = dbClient.openSession(false);
try {
DebtModel debtModel = new DebtModel();
- List<CharacteristicDto> characteristicDtos = dao.selectEnabledCharacteristics(session);
+ List<CharacteristicDto> characteristicDtos = dbClient.debtCharacteristicDao().selectEnabledCharacteristics(session);
for (CharacteristicDto characteristicDto : characteristicDtos) {
if (characteristicDto.getParentId() == null) {
debtModel.addRootCharacteristic(toDebtCharacteristic(characteristicDto));
}
List<RuleDebt> rules = newArrayList();
- for (RuleDto rule : ruleDao.selectEnablesAndNonManual(session)) {
+ for (RuleDto rule : dbClient.ruleDao().selectEnabledAndNonManual(session)) {
if (languageKey == null || languageKey.equals(rule.getLanguage())) {
RuleDebt ruleDebt = toRuleDebt(rule, debtModel);
if (ruleDebt != null) {
checkPermission();
Date updateDate = new Date(system2.now());
- DbSession session = mybatis.openSession(false);
+ DbSession session = dbClient.openSession(false);
try {
// Restore characteristics
List<CharacteristicDto> allCharacteristicDtos = restoreCharacteristics(loadModelFromPlugin(DebtModelPluginRepository.DEFAULT_MODEL), updateDate, session);
// Restore rules
- List<RuleDto> ruleDtos = ruleDao.selectEnablesAndNonManual(session);
+ List<RuleDto> ruleDtos = dbClient.ruleDao().selectEnabledAndNonManual(session);
if (!ruleDtos.isEmpty()) {
// Load default rule definitions
}
}
- private void resetRules(List<RuleDto> ruleDtos, List<RulesDefinition.Rule> rules, List<CharacteristicDto> allCharacteristicDtos, Date updateDate, DbSession session){
+ private void resetRules(List<RuleDto> ruleDtos, List<RulesDefinition.Rule> rules, List<CharacteristicDto> allCharacteristicDtos, Date updateDate, DbSession session) {
for (RuleDto rule : ruleDtos) {
// Restore default debt definitions
rule.setRemediationCoefficient(null);
rule.setRemediationOffset(null);
rule.setUpdatedAt(updateDate);
- ruleDao.update(rule, session);
+ dbClient.ruleDao().update(rule, session);
}
- ruleRegistry.reindex(ruleDtos, session);
}
/**
ValidationMessages validationMessages = ValidationMessages.create();
Date updateDate = new Date(system2.now());
- DbSession session = mybatis.openSession(false);
+ DbSession session = dbClient.openSession(false);
try {
List<CharacteristicDto> allCharacteristicDtos = restoreCharacteristics(characteristicsXMLImporter.importXML(xml), updateDate, session);
restoreRules(allCharacteristicDtos, rules(languageKey, session), rulesXMLImporter.importXML(xml, validationMessages), validationMessages, updateDate, session);
rule.setUpdatedAt(updateDate);
ruleDebts.remove(ruleDebt);
}
- ruleRegistry.reindex(rules, session);
for (RuleDebt ruleDebt : ruleDebts) {
validationMessages.addWarningText(String.format("The rule '%s' does not exist.", ruleDebt.ruleKey()));
@VisibleForTesting
List<CharacteristicDto> restoreCharacteristics(DebtModel targetModel, Date updateDate, DbSession session) {
- List<CharacteristicDto> sourceCharacteristics = dao.selectEnabledCharacteristics(session);
+ List<CharacteristicDto> sourceCharacteristics = dbClient.debtCharacteristicDao().selectEnabledCharacteristics(session);
List<CharacteristicDto> result = newArrayList();
}
private CharacteristicDto restoreCharacteristic(DebtCharacteristic targetCharacteristic, @Nullable Integer parentId, List<CharacteristicDto> sourceCharacteristics,
- Date updateDate, SqlSession session) {
+ Date updateDate, DbSession session) {
CharacteristicDto sourceCharacteristic = characteristicByKey(targetCharacteristic.key(), sourceCharacteristics, false);
if (sourceCharacteristic == null) {
CharacteristicDto newCharacteristic = toDto(targetCharacteristic, parentId).setCreatedAt(updateDate);
- dao.insert(newCharacteristic, session);
+ dbClient.debtCharacteristicDao().insert(newCharacteristic, session);
return newCharacteristic;
} else {
// Update only if modifications
sourceCharacteristic.setOrder(targetCharacteristic.order());
sourceCharacteristic.setParentId(parentId);
sourceCharacteristic.setUpdatedAt(updateDate);
- dao.update(sourceCharacteristic, session);
+ dbClient.debtCharacteristicDao().update(sourceCharacteristic, session);
}
return sourceCharacteristic;
}
}
}
- private List<RuleDto> rules(@Nullable final String languageKey, SqlSession session) {
- List<RuleDto> rules = ruleDao.selectEnablesAndNonManual(session);
+ private List<RuleDto> rules(@Nullable final String languageKey, DbSession session) {
+ List<RuleDto> rules = dbClient.ruleDao().selectEnabledAndNonManual(session);
if (languageKey == null) {
return rules;
} else {
import org.sonar.core.permission.GlobalPermissions;
import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
-import org.sonar.core.rule.RuleDao;
import org.sonar.core.rule.RuleDto;
-import org.sonar.core.technicaldebt.db.CharacteristicDao;
import org.sonar.core.technicaldebt.db.CharacteristicDto;
+import org.sonar.server.db.DbClient;
import org.sonar.server.exceptions.BadRequestException;
import org.sonar.server.exceptions.NotFoundException;
-import org.sonar.server.rule.RuleRegistry;
import org.sonar.server.user.UserSession;
import org.sonar.server.util.Validation;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
-
import java.util.Date;
import java.util.List;
public class DebtModelOperations implements ServerComponent {
- private final MyBatis mybatis;
- private final CharacteristicDao dao;
- private final RuleDao ruleDao;
+ private final DbClient dbClient;
private final System2 system2;
- private final RuleRegistry ruleRegistry;
- public DebtModelOperations(MyBatis mybatis, CharacteristicDao dao, RuleDao ruleDao, RuleRegistry ruleRegistry) {
- this(mybatis, dao, ruleDao, ruleRegistry, System2.INSTANCE);
+ public DebtModelOperations(DbClient dbClient) {
+ this(dbClient, System2.INSTANCE);
}
@VisibleForTesting
- DebtModelOperations(MyBatis mybatis, CharacteristicDao dao, RuleDao ruleDao, RuleRegistry ruleRegistry, System2 system2) {
- this.mybatis = mybatis;
- this.dao = dao;
- this.ruleDao = ruleDao;
- this.ruleRegistry = ruleRegistry;
+ DebtModelOperations(DbClient dbClient, System2 system2) {
+ this.dbClient = dbClient;
this.system2 = system2;
}
public DebtCharacteristic create(String name, @Nullable Integer parentId) {
checkPermission();
- SqlSession session = mybatis.openSession(false);
+ SqlSession session = dbClient.openSession(false);
try {
checkNotAlreadyExists(name, session);
newCharacteristic.setParentId(parent.getId());
} else {
// New root characteristic
- newCharacteristic.setOrder(dao.selectMaxCharacteristicOrder(session) + 1);
+ newCharacteristic.setOrder(dbClient.debtCharacteristicDao().selectMaxCharacteristicOrder(session) + 1);
}
- dao.insert(newCharacteristic, session);
+ dbClient.debtCharacteristicDao().insert(newCharacteristic, session);
session.commit();
return toCharacteristic(newCharacteristic);
} finally {
public DebtCharacteristic rename(int characteristicId, String newName) {
checkPermission();
- SqlSession session = mybatis.openSession(false);
+ SqlSession session = dbClient.openSession(false);
try {
checkNotAlreadyExists(newName, session);
if (!dto.getName().equals(newName)) {
dto.setName(newName);
dto.setUpdatedAt(new Date(system2.now()));
- dao.update(dto, session);
+ dbClient.debtCharacteristicDao().update(dto, session);
session.commit();
}
return toCharacteristic(dto);
private DebtCharacteristic move(int characteristicId, boolean moveUpOrDown) {
checkPermission();
- SqlSession session = mybatis.openSession(false);
+ SqlSession session = dbClient.openSession(false);
try {
final CharacteristicDto dto = findCharacteristic(characteristicId, session);
if (dto.getParentId() != null) {
int nextOrder = getOrder(dtoToSwitchOrderWith);
dtoToSwitchOrderWith.setOrder(currentOrder);
dtoToSwitchOrderWith.setUpdatedAt(new Date(system2.now()));
- dao.update(dtoToSwitchOrderWith, session);
+ dbClient.debtCharacteristicDao().update(dtoToSwitchOrderWith, session);
dto.setOrder(nextOrder);
dto.setUpdatedAt(new Date(system2.now()));
- dao.update(dto, session);
+ dbClient.debtCharacteristicDao().update(dto, session);
session.commit();
return toCharacteristic(dto);
}
}
- private int getOrder(CharacteristicDto characteristicDto){
- Integer order= characteristicDto.getOrder();
+ private int getOrder(CharacteristicDto characteristicDto) {
+ Integer order = characteristicDto.getOrder();
if (order == null) {
throw new IllegalArgumentException(String.format("The order of the characteristic '%s' should not be null", characteristicDto.getKey()));
}
@CheckForNull
private CharacteristicDto findCharacteristicToSwitchWith(final CharacteristicDto dto, final boolean moveUpOrDown, SqlSession session) {
// characteristics should be sort by 'order'
- List<CharacteristicDto> rootCharacteristics = dao.selectEnabledRootCharacteristics(session);
+ List<CharacteristicDto> rootCharacteristics = dbClient.debtCharacteristicDao().selectEnabledRootCharacteristics(session);
int currentPosition = Iterables.indexOf(rootCharacteristics, new Predicate<CharacteristicDto>() {
@Override
public boolean apply(@Nullable CharacteristicDto input) {
checkPermission();
Date updateDate = new Date(system2.now());
- DbSession session = mybatis.openSession(true);
+ DbSession session = dbClient.openSession(true);
try {
delete(findCharacteristic(characteristicId, session), updateDate, session);
session.commit();
if (characteristicOrSubCharacteristic.isEnabled()) {
// When root characteristic, browse sub characteristics and disable rule debt on each sub characteristic then disable it
if (characteristicOrSubCharacteristic.getParentId() == null) {
- List<CharacteristicDto> subCharacteristics = dao.selectCharacteristicsByParentId(characteristicOrSubCharacteristic.getId(), session);
+ List<CharacteristicDto> subCharacteristics = dbClient.debtCharacteristicDao().selectCharacteristicsByParentId(characteristicOrSubCharacteristic.getId(), session);
for (CharacteristicDto subCharacteristic : subCharacteristics) {
disableSubCharacteristic(subCharacteristic, updateDate, session);
}
private void disableSubCharacteristic(CharacteristicDto subCharacteristic, Date updateDate, DbSession session) {
// Disable debt on all rules (even REMOVED ones, in order to have no issue if they are reactivated) linked to the sub characteristic
- disableRulesDebt(ruleDao.selectBySubCharacteristicId(subCharacteristic.getId(), session), subCharacteristic.getId(), updateDate, session);
+ disableRulesDebt(dbClient.ruleDao().findRulesByDebtSubCharacteristicId(subCharacteristic.getId(), session), subCharacteristic.getId(), updateDate, session);
disableCharacteristic(subCharacteristic, updateDate, session);
}
private void disableCharacteristic(CharacteristicDto characteristic, Date updateDate, SqlSession session) {
characteristic.setEnabled(false);
characteristic.setUpdatedAt(updateDate);
- dao.update(characteristic, session);
+ dbClient.debtCharacteristicDao().update(characteristic, session);
}
private void disableRulesDebt(List<RuleDto> ruleDtos, Integer subCharacteristicId, Date updateDate, DbSession session) {
ruleDto.setDefaultRemediationCoefficient(null);
ruleDto.setDefaultRemediationOffset(null);
}
- ruleDto.setUpdatedAt(updateDate);
- ruleDao.update(ruleDto, session);
+ dbClient.ruleDao().update(ruleDto, session);
}
- ruleRegistry.reindex(ruleDtos, session);
}
private CharacteristicDto findCharacteristic(Integer id, SqlSession session) {
- CharacteristicDto dto = dao.selectById(id, session);
+ CharacteristicDto dto = dbClient.debtCharacteristicDao().selectById(id, session);
if (dto == null) {
throw new NotFoundException(String.format("Characteristic with id %s does not exists.", id));
}
}
private void checkNotAlreadyExists(String name, SqlSession session) {
- if (dao.selectByName(name, session) != null) {
+ if (dbClient.debtCharacteristicDao().selectByName(name, session) != null) {
throw BadRequestException.ofL10n(Validation.IS_ALREADY_USED_MESSAGE, name);
}
}
import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.Lists;
-import org.sonar.api.DaoComponent;
+import org.sonar.core.persistence.DaoComponent;
import org.sonar.api.ServerComponent;
import org.sonar.api.utils.System2;
import org.sonar.core.measure.db.MeasureDto;
package org.sonar.server.qualityprofile;
import org.sonar.api.ServerComponent;
-import org.sonar.core.qualityprofile.db.QualityProfileDao;
import org.sonar.core.qualityprofile.db.QualityProfileDto;
import org.sonar.server.db.DbClient;
private final DbClient dbClient;
- public QualityProfileService(DbClient dbClient){
+ public QualityProfileService(DbClient dbClient) {
this.dbClient = dbClient;
}
public List<QualityProfileDto> findAll() {
- return dbClient.getDao(QualityProfileDao.class).selectAll();
+ return dbClient.qualityProfileDao().selectAll();
}
}
import org.sonar.api.profiles.ProfileDefinition;
import org.sonar.api.profiles.RulesProfile;
import org.sonar.api.rule.RuleKey;
-import org.sonar.api.rules.*;
+import org.sonar.api.rules.ActiveRuleParam;
import org.sonar.api.utils.TimeProfiler;
import org.sonar.api.utils.ValidationMessages;
import org.sonar.core.permission.GlobalPermissions;
import org.sonar.core.qualityprofile.db.ActiveRuleParamDto;
import org.sonar.core.qualityprofile.db.QualityProfileDto;
import org.sonar.core.rule.RuleDto;
-import org.sonar.core.template.LoadedTemplateDao;
import org.sonar.core.template.LoadedTemplateDto;
import org.sonar.jpa.session.DatabaseSessionFactory;
import org.sonar.server.db.DbClient;
private QualityProfileDto newQualityProfileDto(String name, String language, DbSession session) {
checkPermission(UserSession.get());
- if (dbClient.qualityProfileDao().selectByNameAndLanguage(name, language, session) != null) {
- throw BadRequestException.ofL10n("quality_profiles.profile_x_already_exists", name);
- }
+ if (dbClient.qualityProfileDao().selectByNameAndLanguage(name, language, session) != null) {
+ throw BadRequestException.ofL10n("quality_profiles.profile_x_already_exists", name);
+ }
- QualityProfileDto profile = QualityProfileDto.createFor(name, language)
+ QualityProfileDto profile = QualityProfileDto.createFor(name, language)
.setVersion(1).setUsed(false);
dbClient.qualityProfileDao().insert(profile, session);
return profile;
}
}
- dbClient.getDao(LoadedTemplateDao.class)
+ dbClient.loadedTemplateDao()
.insert(new LoadedTemplateDto(templateKey(language, name), LoadedTemplateDto.QUALITY_PROFILE_TYPE), session);
}
}
private boolean shouldRegister(String language, String profileName, SqlSession session) {
- return dbClient.getDao(LoadedTemplateDao.class)
+ return dbClient.loadedTemplateDao()
.countByTypeAndKey(LoadedTemplateDto.QUALITY_PROFILE_TYPE, templateKey(language, profileName), session) == 0;
}
DbSession session = db.openSession(false);
try {
//TODO because DTO uses legacy ID pattern
- QualityProfileDto profile = db.getDao(QualityProfileDao.class)
+ QualityProfileDto profile = db.qualityProfileDao()
.selectById(activeRuleDto.getProfileId());
newRule.put(ActiveRuleField.PROFILE_KEY.key(), profile.getKey().toString());
import org.sonar.server.util.RubyUtils;
import javax.annotation.CheckForNull;
-import javax.annotation.Nullable;
-
import java.util.Map;
/**
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Strings;
import org.apache.commons.lang.builder.EqualsBuilder;
-import org.apache.ibatis.session.SqlSession;
import org.sonar.api.ServerComponent;
import org.sonar.api.rule.RuleKey;
import org.sonar.api.server.debt.DebtRemediationFunction;
import org.sonar.core.permission.GlobalPermissions;
import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
-import org.sonar.core.rule.RuleDao;
import org.sonar.core.rule.RuleDto;
-import org.sonar.core.technicaldebt.db.CharacteristicDao;
import org.sonar.core.technicaldebt.db.CharacteristicDto;
+import org.sonar.server.db.DbClient;
import org.sonar.server.exceptions.BadRequestException;
import org.sonar.server.exceptions.NotFoundException;
import org.sonar.server.user.UserSession;
@Deprecated
public class RuleOperations implements ServerComponent {
- private final MyBatis myBatis;
- private final RuleDao ruleDao;
- private final CharacteristicDao characteristicDao;
- private final RuleRegistry ruleRegistry;
-
+ private final DbClient dbClient;
private final System2 system;
- public RuleOperations(MyBatis myBatis, RuleDao ruleDao, CharacteristicDao characteristicDao,
- RuleRegistry ruleRegistry) {
- this(myBatis, ruleDao, characteristicDao, ruleRegistry, System2.INSTANCE);
+ public RuleOperations(DbClient dbClient) {
+ this(dbClient, System2.INSTANCE);
}
@VisibleForTesting
- RuleOperations(MyBatis myBatis, RuleDao ruleDao, CharacteristicDao characteristicDao,
- RuleRegistry ruleRegistry, System2 system) {
- this.myBatis = myBatis;
- this.ruleDao = ruleDao;
- this.characteristicDao = characteristicDao;
- this.ruleRegistry = ruleRegistry;
+ RuleOperations(DbClient dbClient, System2 system) {
+ this.dbClient = dbClient;
this.system = system;
}
public void updateRule(RuleChange ruleChange, UserSession userSession) {
checkPermission(userSession);
- DbSession session = myBatis.openSession(false);
+ DbSession session = dbClient.openSession(false);
try {
- RuleDto ruleDto = ruleDao.selectByKey(ruleChange.ruleKey(), session);
+ RuleDto ruleDto = dbClient.ruleDao().getByKey(ruleChange.ruleKey(), session);
if (ruleDto == null) {
throw new NotFoundException(String.format("Unknown rule '%s'", ruleChange.ruleKey()));
}
// A sub-characteristic is given -> update rule debt if given values are different from overridden ones and from default ones
if (!Strings.isNullOrEmpty(subCharacteristicKey)) {
- subCharacteristic = characteristicDao.selectByKey(subCharacteristicKey, session);
+ subCharacteristic = dbClient.debtCharacteristicDao().selectByKey(subCharacteristicKey, session);
if (subCharacteristic == null) {
throw new NotFoundException(String.format("Unknown sub characteristic '%s'", ruleChange.debtCharacteristicKey()));
}
new Date(system.now()), session);
if (needUpdate) {
session.commit();
- reindexRule(ruleDto, session);
}
} catch (IllegalArgumentException e) {
throw BadRequestException.of(e.getMessage());
}
if (needUpdate) {
- ruleDto.setUpdatedAt(updateDate);
- ruleDao.update(ruleDto, session);
+ dbClient.ruleDao().update(ruleDto, session);
}
return needUpdate;
}
.isEquals();
}
- private void reindexRule(RuleDto rule, SqlSession session) {
- ruleRegistry.reindex(rule, session);
- }
-
private void checkPermission(UserSession userSession) {
userSession.checkLoggedIn();
userSession.checkGlobalPermission(GlobalPermissions.QUALITY_PROFILE_ADMIN);
}
}
- public String[] reindex(SqlSession session) {
+ String[] reindex(SqlSession session) {
return reindex(ruleDao.selectEnablesAndNonManual(session), session);
}
/**
* Reindex one rule
*/
- public void reindex(RuleDto rule) {
+ void reindex(RuleDto rule) {
SqlSession sqlSession = myBatis.openSession(false);
try {
reindex(rule, sqlSession);
}
}
- public void removeDeletedRules(String[] ids) {
- List<String> indexIds = searchIndex.findDocumentIds(SearchQuery.create().index(INDEX_RULES).type(TYPE_RULE));
- indexIds.removeAll(Arrays.asList(ids));
- if (!indexIds.isEmpty()) {
- TIME_PROFILER.start("Remove deleted rule documents");
- searchIndex.bulkDelete(INDEX_RULES, TYPE_RULE, indexIds.toArray(new String[0]));
- TIME_PROFILER.stop();
- }
- }
-
private XContentBuilder ruleDocument(RuleDto rule, @Nullable CharacteristicDto characteristicDto, @Nullable CharacteristicDto subCharacteristicDto,
Collection<RuleParamDto> params) throws IOException {
XContentBuilder document = XContentFactory.jsonBuilder()
this.defLoader = defLoader;
this.profilesManager = profilesManager;
this.dbClient = dbClient;
- this.characteristicDao = dbClient.getDao(CharacteristicDao.class);
+ this.characteristicDao = dbClient.debtCharacteristicDao();
}
@Override
// TODO store param name
if (mergeParam(paramDto, paramDef)) {
dbClient.ruleDao().updateRuleParam(rule, paramDto, session);
- } else {
+ } else {
// TODO to be replaced by synchronizer
session.enqueue(new EmbeddedIndexAction<RuleKey>(RuleIndexDefinition.INDEX_TYPE, IndexAction.Method.UPDATE, paramDto, rule.getKey()));
}
Preconditions.checkNotNull(rule.getId(), "Rule is not persisted");
return mapper(session).selectParamByRuleAndKey(rule.getId(), key);
}
+
+ public List<RuleDto> findRulesByDebtSubCharacteristicId(int id, DbSession session) {
+ return mapper(session).selectBySubCharacteristicId(id);
+ }
+
+ public List<RuleDto> selectEnabledAndNonManual(DbSession session) {
+ return mapper(session).selectEnablesAndNonManual();
+ }
}
import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
import org.sonar.server.db.DbClient;
-import org.sonar.server.measure.persistence.MeasureDao;
import org.sonar.server.user.UserSession;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
-
import java.util.List;
public class SourceService implements ServerComponent {
private final DbClient dbClient;
-
private final HtmlSourceDecorator sourceDecorator;
/**
*/
private final DeprecatedSourceDecorator deprecatedSourceDecorator;
- private final MeasureDao measureDao;
-
public SourceService(DbClient dbClient, HtmlSourceDecorator sourceDecorator, DeprecatedSourceDecorator deprecatedSourceDecorator) {
this.dbClient = dbClient;
this.sourceDecorator = sourceDecorator;
this.deprecatedSourceDecorator = deprecatedSourceDecorator;
- this.measureDao = dbClient.getDao(MeasureDao.class);
}
public List<String> getLinesAsHtml(String fileKey) {
}
public boolean hasScmData(String fileKey, DbSession session) {
- return measureDao.existsByKey(MeasureKey.of(fileKey, CoreMetrics.SCM_AUTHORS_BY_LINE_KEY), session);
+ return dbClient.measureDao().existsByKey(MeasureKey.of(fileKey, CoreMetrics.SCM_AUTHORS_BY_LINE_KEY), session);
}
public boolean hasScmData(String fileKey) {
private String findDataFromComponent(String fileKey, String metricKey) {
DbSession session = dbClient.openSession(false);
try {
- MeasureDto data = measureDao.getByKey(MeasureKey.of(fileKey, metricKey), session);
+ MeasureDto data = dbClient.measureDao().getByKey(MeasureKey.of(fileKey, metricKey), session);
if (data != null) {
return data.getData();
}
public void setUp() throws Exception {
DbClient dbClient = mock(DbClient.class);
when(dbClient.openSession(false)).thenReturn(session);
- when(dbClient.getDao(ComponentDao.class)).thenReturn(componentDao);
- when(dbClient.getDao(ResourceDao.class)).thenReturn(resourceDao);
- when(dbClient.getDao(PropertiesDao.class)).thenReturn(propertiesDao);
- when(dbClient.getDao(MeasureDao.class)).thenReturn(measureDao);
+ when(dbClient.componentDao()).thenReturn(componentDao);
+ when(dbClient.resourceDao()).thenReturn(resourceDao);
+ when(dbClient.propertiesDao()).thenReturn(propertiesDao);
+ when(dbClient.measureDao()).thenReturn(measureDao);
when(issueService.findSeveritiesByComponent(anyString(), eq(session))).thenReturn(mock(Multiset.class));
when(issueService.findRulesByComponent(anyString(), eq(session))).thenReturn(mock(RulesAggregation.class));
import org.sonar.server.rule2.persistence.RuleDao;
import static org.fest.assertions.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
public class DbClientTest {
@Test
public void facade() throws Exception {
MyBatis myBatis = db.myBatis();
- RuleDao ruleDao = mock(RuleDao.class);
- ActiveRuleDao activeRuleDao = mock(ActiveRuleDao.class);
- QualityProfileDao qualityProfileDao = mock(QualityProfileDao.class);
+ RuleDao ruleDao = new RuleDao();
+ QualityProfileDao qualityProfileDao = new QualityProfileDao(myBatis);
+ ActiveRuleDao activeRuleDao = new ActiveRuleDao(qualityProfileDao, ruleDao);
DbClient client = new DbClient(db.database(), myBatis, ruleDao, activeRuleDao, qualityProfileDao);
dbSession.close();
// DAO
- assertThat(client.getDao(qualityProfileDao.getClass())).isSameAs(qualityProfileDao);
- assertThat(client.getDao(activeRuleDao.getClass())).isSameAs(activeRuleDao);
- assertThat(client.getDao(ruleDao.getClass())).isSameAs(ruleDao);
+ assertThat(client.qualityProfileDao()).isSameAs(qualityProfileDao);
+ assertThat(client.activeRuleDao()).isSameAs(activeRuleDao);
+ assertThat(client.ruleDao()).isSameAs(ruleDao);
}
}
import org.sonar.api.utils.ValidationMessages;
import org.sonar.core.permission.GlobalPermissions;
import org.sonar.core.persistence.DbSession;
-import org.sonar.core.persistence.MyBatis;
-import org.sonar.core.rule.RuleDao;
import org.sonar.core.rule.RuleDto;
import org.sonar.core.technicaldebt.db.CharacteristicDao;
import org.sonar.core.technicaldebt.db.CharacteristicDto;
+import org.sonar.server.db.DbClient;
import org.sonar.server.debt.DebtModelXMLExporter.DebtModel;
import org.sonar.server.debt.DebtModelXMLExporter.RuleDebt;
import org.sonar.server.rule.RuleDefinitionsLoader;
import org.sonar.server.rule.RuleOperations;
-import org.sonar.server.rule.RuleRegistry;
+import org.sonar.server.rule2.persistence.RuleDao;
import org.sonar.server.user.MockUserSession;
import java.io.Reader;
public class DebtModelBackupTest {
@Mock
- MyBatis myBatis;
+ DbClient dbClient;
@Mock
DbSession session;
@Mock
DebtModelXMLExporter debtModelXMLExporter;
- @Mock
- RuleRegistry ruleRegistry;
-
@Mock
RuleDefinitionsLoader defLoader;
}
}).when(dao).insert(any(CharacteristicDto.class), any(DbSession.class));
- when(myBatis.openSession(false)).thenReturn(session);
+ when(dbClient.openSession(false)).thenReturn(session);
+ when(dbClient.ruleDao()).thenReturn(ruleDao);
+ when(dbClient.debtCharacteristicDao()).thenReturn(dao);
Reader defaultModelReader = mock(Reader.class);
when(debtModelPluginRepository.createReaderForXMLFile("technical-debt")).thenReturn(defaultModelReader);
- debtModelBackup = new DebtModelBackup(myBatis, dao, ruleDao, debtModelOperations, ruleOperations, debtModelPluginRepository, characteristicsXMLImporter, rulesXMLImporter,
- debtModelXMLExporter, ruleRegistry, defLoader, system2);
+ debtModelBackup = new DebtModelBackup(dbClient, debtModelOperations, ruleOperations, debtModelPluginRepository, characteristicsXMLImporter, rulesXMLImporter,
+ debtModelXMLExporter, defLoader, system2);
}
@Test
new CharacteristicDto().setId(2).setKey("COMPILER").setName("Compiler updated").setParentId(1)
));
- when(ruleDao.selectEnablesAndNonManual(session)).thenReturn(newArrayList(
+ when(ruleDao.selectEnabledAndNonManual(session)).thenReturn(newArrayList(
// Rule with overridden debt values
new RuleDto().setRepositoryKey("squid").setRuleKey("UselessImportCheck")
.setSubCharacteristicId(2)
new CharacteristicDto().setId(2).setKey("COMPILER").setName("Compiler updated").setParentId(1)
));
- when(ruleDao.selectEnablesAndNonManual(session)).thenReturn(newArrayList(
+ when(ruleDao.selectEnabledAndNonManual(session)).thenReturn(newArrayList(
// Debt disabled
new RuleDto().setRepositoryKey("squid").setRuleKey("UselessImportCheck").setSubCharacteristicId(RuleDto.DISABLED_CHARACTERISTIC_ID),
new CharacteristicDto().setId(2).setKey("COMPILER").setName("Compiler updated").setParentId(1)
));
- when(ruleDao.selectEnablesAndNonManual(session)).thenReturn(newArrayList(
+ when(ruleDao.selectEnabledAndNonManual(session)).thenReturn(newArrayList(
// Rule with default debt values : default value is linear (only coefficient is set) and overridden value is constant per issue (only offset is set)
// -> Ony offset should be set
new RuleDto().setRepositoryKey("squid").setRuleKey("AvoidNPE")
new CharacteristicDto().setId(2).setKey("COMPILER").setName("Compiler updated").setParentId(1)
));
- when(ruleDao.selectEnablesAndNonManual(session)).thenReturn(newArrayList(
+ when(ruleDao.selectEnabledAndNonManual(session)).thenReturn(newArrayList(
new RuleDto().setId(1).setRepositoryKey("squid").setRuleKey("UselessImportCheck").setLanguage("java")
.setSubCharacteristicId(2)
.setRemediationFunction(DebtRemediationFunction.Type.CONSTANT_ISSUE.toString())
new CharacteristicDto().setId(2).setKey("COMPILER").setName("Compiler updated").setParentId(1)//.setCreatedAt(oldDate)
));
- when(ruleDao.selectEnablesAndNonManual(session)).thenReturn(newArrayList(
+ when(ruleDao.selectEnabledAndNonManual(session)).thenReturn(newArrayList(
new RuleDto().setRepositoryKey("squid").setRuleKey("NPE")
.setDefaultSubCharacteristicId(10)
.setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR.toString())
verify(dao, times(2)).update(any(CharacteristicDto.class), eq(session));
verifyNoMoreInteractions(dao);
- verify(ruleDao).selectEnablesAndNonManual(session);
+ verify(ruleDao).selectEnabledAndNonManual(session);
verify(ruleDao).update(ruleCaptor.capture(), eq(session));
verifyNoMoreInteractions(ruleDao);
- verify(ruleRegistry).reindex(ruleCaptor.getAllValues(), session);
verify(session).commit();
new CharacteristicDto().setId(2).setKey("COMPILER").setName("Compiler updated").setParentId(1).setCreatedAt(oldDate)
));
- when(ruleDao.selectEnablesAndNonManual(session)).thenReturn(newArrayList(
+ when(ruleDao.selectEnabledAndNonManual(session)).thenReturn(newArrayList(
new RuleDto().setRepositoryKey("squid").setRuleKey("NPE")
.setDefaultSubCharacteristicId(10)
.setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR.toString())
verify(dao, times(2)).update(any(CharacteristicDto.class), eq(session));
verifyNoMoreInteractions(dao);
- verify(ruleDao).selectEnablesAndNonManual(session);
+ verify(ruleDao).selectEnabledAndNonManual(session);
verify(ruleDao).update(ruleCaptor.capture(), eq(session));
verifyNoMoreInteractions(ruleDao);
- verify(ruleRegistry).reindex(ruleCaptor.getAllValues(), session);
verify(session).commit();
new CharacteristicDto().setId(2).setKey("COMPILER").setName("Compiler updated").setParentId(1).setCreatedAt(oldDate)
));
- when(ruleDao.selectEnablesAndNonManual(session)).thenReturn(newArrayList(
+ when(ruleDao.selectEnabledAndNonManual(session)).thenReturn(newArrayList(
// Template rule
new RuleDto().setId(5).setRepositoryKey("squid").setRuleKey("XPath")
.setSubCharacteristicId(2)
debtModelBackup.reset();
- verify(ruleDao).selectEnablesAndNonManual(session);
+ verify(ruleDao).selectEnabledAndNonManual(session);
verify(ruleDao, times(2)).update(ruleCaptor.capture(), eq(session));
verifyNoMoreInteractions(ruleDao);
- verify(ruleRegistry).reindex(ruleCaptor.getAllValues(), session);
verify(session).commit();
RuleDto rule = ruleCaptor.getAllValues().get(1);
new CharacteristicDto().setId(2).setKey("COMPILER").setName("Compiler updated").setParentId(1).setCreatedAt(oldDate)
));
- when(ruleDao.selectEnablesAndNonManual(session)).thenReturn(Collections.<RuleDto>emptyList());
+ when(ruleDao.selectEnabledAndNonManual(session)).thenReturn(Collections.<RuleDto>emptyList());
debtModelBackup.reset();
verify(dao, times(2)).update(any(CharacteristicDto.class), eq(session));
verifyNoMoreInteractions(dao);
- verify(ruleDao).selectEnablesAndNonManual(session);
+ verify(ruleDao).selectEnabledAndNonManual(session);
verify(ruleDao, never()).update(any(RuleDto.class), eq(session));
- verifyZeroInteractions(ruleRegistry);
verifyZeroInteractions(defLoader);
verify(session).commit();
.setSubCharacteristicKey("COMPILER")
.setFunction(DebtRemediationFunction.Type.LINEAR.name()).setCoefficient("2h")));
- when(ruleDao.selectEnablesAndNonManual(session)).thenReturn(newArrayList(
+ when(ruleDao.selectEnabledAndNonManual(session)).thenReturn(newArrayList(
new RuleDto().setId(1).setRepositoryKey("squid").setRuleKey("UselessImportCheck")
.setDefaultSubCharacteristicId(3).setDefaultRemediationFunction("LINEAR").setDefaultRemediationCoefficient("2h")
// .setCreatedAt(oldDate).setUpdatedAt(oldDate)
verify(ruleOperations).updateRule(ruleCaptor.capture(), eq(compiler), eq("LINEAR"), eq("2h"), isNull(String.class), eq(now), eq(session));
- verify(ruleDao).selectEnablesAndNonManual(session);
- verify(ruleRegistry).reindex(ruleCaptor.getAllValues(), session);
+ verify(ruleDao).selectEnabledAndNonManual(session);
verify(session).commit();
}
new CharacteristicDto().setId(1).setKey("PORTABILITY").setName("Portability").setOrder(1).setCreatedAt(oldDate),
new CharacteristicDto().setId(2).setKey("COMPILER").setName("Compiler").setParentId(1).setCreatedAt(oldDate)));
- when(ruleDao.selectEnablesAndNonManual(session)).thenReturn(newArrayList(
+ when(ruleDao.selectEnabledAndNonManual(session)).thenReturn(newArrayList(
new RuleDto().setId(1).setRepositoryKey("squid").setRuleKey("UselessImportCheck")
.setDefaultSubCharacteristicId(2).setDefaultRemediationFunction("LINEAR_OFFSET").setDefaultRemediationCoefficient("2h").setDefaultRemediationOffset("15min")
// .setCreatedAt(oldDate).setUpdatedAt(oldDate)
verify(ruleOperations).updateRule(ruleCaptor.capture(), isNull(CharacteristicDto.class), isNull(String.class), isNull(String.class), isNull(String.class), eq(now), eq(session));
- verify(ruleDao).selectEnablesAndNonManual(session);
- verify(ruleRegistry).reindex(ruleCaptor.getAllValues(), session);
+ verify(ruleDao).selectEnabledAndNonManual(session);
verify(session).commit();
}
when(rulesXMLImporter.importXML(anyString(), any(ValidationMessages.class))).thenReturn(newArrayList(new RuleDebt()
.setRuleKey(RuleKey.of("squid", "UselessImportCheck")).setSubCharacteristicKey("COMPILER").setFunction(DebtRemediationFunction.Type.LINEAR.name()).setCoefficient("2h")));
- when(ruleDao.selectEnablesAndNonManual(session)).thenReturn(newArrayList(
+ when(ruleDao.selectEnabledAndNonManual(session)).thenReturn(newArrayList(
new RuleDto().setId(1).setRepositoryKey("squid").setRuleKey("UselessImportCheck").setLanguage("java")
.setDefaultSubCharacteristicId(10)
.setDefaultRemediationFunction(DebtRemediationFunction.Type.LINEAR.toString())
verify(ruleOperations).updateRule(ruleCaptor.capture(), eq(compiler), eq("LINEAR"), eq("2h"), isNull(String.class), eq(now), eq(session));
- verify(ruleDao).selectEnablesAndNonManual(session);
- verify(ruleRegistry).reindex(ruleCaptor.getAllValues(), session);
+ verify(ruleDao).selectEnabledAndNonManual(session);
verify(session).commit();
}
));
when(rulesXMLImporter.importXML(anyString(), any(ValidationMessages.class))).thenReturn(Collections.<RuleDebt>emptyList());
- when(ruleDao.selectEnablesAndNonManual(session)).thenReturn(newArrayList(
+ when(ruleDao.selectEnabledAndNonManual(session)).thenReturn(newArrayList(
// Rule does not exits in XML -> debt will be disabled
new RuleDto().setId(1).setRepositoryKey("squid").setRuleKey("UselessImportCheck").setLanguage("java")
.setDefaultSubCharacteristicId(2).setDefaultRemediationFunction("LINEAR").setDefaultRemediationCoefficient("2h")
verify(ruleOperations).updateRule(ruleCaptor.capture(), isNull(CharacteristicDto.class), isNull(String.class), isNull(String.class), isNull(String.class), eq(now), eq(session));
- verify(ruleDao).selectEnablesAndNonManual(session);
- verify(ruleRegistry).reindex(ruleCaptor.getAllValues(), session);
+ verify(ruleDao).selectEnabledAndNonManual(session);
verify(session).commit();
}
when(rulesXMLImporter.importXML(anyString(), any(ValidationMessages.class))).thenReturn(newArrayList(new RuleDebt()
.setRuleKey(RuleKey.of("squid", "UselessImportCheck")).setSubCharacteristicKey("COMPILER").setFunction(DebtRemediationFunction.Type.LINEAR.name()).setCoefficient("2h")));
- when(ruleDao.selectEnablesAndNonManual(session)).thenReturn(Collections.<RuleDto>emptyList());
+ when(ruleDao.selectEnabledAndNonManual(session)).thenReturn(Collections.<RuleDto>emptyList());
assertThat(debtModelBackup.restoreFromXml("<xml/>").getWarnings()).hasSize(1);
verifyZeroInteractions(ruleOperations);
- verify(ruleDao).selectEnablesAndNonManual(session);
- verify(ruleRegistry).reindex(ruleCaptor.getAllValues(), session);
+ verify(ruleDao).selectEnabledAndNonManual(session);
verify(session).commit();
}
when(rulesXMLImporter.importXML(anyString(), any(ValidationMessages.class))).thenReturn(newArrayList(new RuleDebt()
.setRuleKey(RuleKey.of("squid", "UselessImportCheck")).setSubCharacteristicKey("COMPILER").setFunction(DebtRemediationFunction.Type.LINEAR.name()).setCoefficient("2h")));
- when(ruleDao.selectEnablesAndNonManual(session)).thenReturn(newArrayList(
+ when(ruleDao.selectEnabledAndNonManual(session)).thenReturn(newArrayList(
new RuleDto().setId(1).setRepositoryKey("squid").setRuleKey("UselessImportCheck")
.setDefaultSubCharacteristicId(3).setDefaultRemediationFunction("LINEAR").setDefaultRemediationCoefficient("2h")
// .setCreatedAt(oldDate).setUpdatedAt(oldDate)
assertThat(debtModelBackup.restoreFromXml("<xml/>").getErrors()).hasSize(1);
- verify(ruleDao).selectEnablesAndNonManual(session);
- verifyZeroInteractions(ruleRegistry);
+ verify(ruleDao).selectEnabledAndNonManual(session);
verify(session, never()).commit();
}
import org.sonar.api.utils.System2;
import org.sonar.core.permission.GlobalPermissions;
import org.sonar.core.persistence.DbSession;
-import org.sonar.core.persistence.MyBatis;
-import org.sonar.core.rule.RuleDao;
import org.sonar.core.rule.RuleDto;
import org.sonar.core.technicaldebt.db.CharacteristicDao;
import org.sonar.core.technicaldebt.db.CharacteristicDto;
+import org.sonar.server.db.DbClient;
import org.sonar.server.exceptions.BadRequestException;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.exceptions.NotFoundException;
-import org.sonar.server.rule.RuleRegistry;
+import org.sonar.server.rule2.persistence.RuleDao;
import org.sonar.server.user.MockUserSession;
import java.util.Date;
RuleDao ruleDao;
@Mock
- MyBatis mybatis;
+ DbClient dbClient;
@Mock
DbSession session;
- @Mock
- RuleRegistry ruleRegistry;
-
@Mock
System2 system2;
}
}).when(dao).insert(any(CharacteristicDto.class), any(SqlSession.class));
- when(mybatis.openSession(false)).thenReturn(session);
- service = new DebtModelOperations(mybatis, dao, ruleDao, ruleRegistry, system2);
+ when(dbClient.openSession(false)).thenReturn(session);
+ when(dbClient.ruleDao()).thenReturn(ruleDao);
+ when(dbClient.debtCharacteristicDao()).thenReturn(dao);
+ service = new DebtModelOperations(dbClient, system2);
}
@Test
@Test
public void delete_sub_characteristic() {
DbSession batchSession = mock(DbSession.class);
- when(mybatis.openSession(true)).thenReturn(batchSession);
+ when(dbClient.openSession(true)).thenReturn(batchSession);
- when(ruleDao.selectBySubCharacteristicId(2, batchSession)).thenReturn(newArrayList(
+ when(ruleDao.findRulesByDebtSubCharacteristicId(2, batchSession)).thenReturn(newArrayList(
new RuleDto()
.setSubCharacteristicId(2)
.setRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.toString())
assertThat(characteristicDto.getId()).isEqualTo(2);
assertThat(characteristicDto.isEnabled()).isFalse();
assertThat(characteristicDto.getUpdatedAt()).isEqualTo(now);
-
- verify(ruleRegistry).reindex(ruleCaptor.getAllValues(), batchSession);
}
@Test
public void delete_sub_characteristic_disable_default_rules_debt_if_default_characteristic_is_deleted() {
DbSession batchSession = mock(DbSession.class);
- when(mybatis.openSession(true)).thenReturn(batchSession);
+ when(dbClient.openSession(true)).thenReturn(batchSession);
- when(ruleDao.selectBySubCharacteristicId(2, batchSession)).thenReturn(newArrayList(
+ when(ruleDao.findRulesByDebtSubCharacteristicId(2, batchSession)).thenReturn(newArrayList(
new RuleDto()
.setSubCharacteristicId(10).setRemediationFunction("LINEAR_OFFSET").setRemediationCoefficient("2h").setRemediationOffset("5min")
.setDefaultSubCharacteristicId(2).setDefaultRemediationFunction("LINEAR_OFFSET").setDefaultRemediationCoefficient("4h").setDefaultRemediationOffset("15min")
verify(ruleDao).update(ruleCaptor.capture(), eq(batchSession));
RuleDto ruleDto = ruleCaptor.getValue();
- assertThat(ruleDto.getUpdatedAt()).isEqualTo(now);
// Default debt data are disabled
assertThat(ruleDto.getDefaultSubCharacteristicId()).isNull();
assertThat(characteristicDto.getId()).isEqualTo(2);
assertThat(characteristicDto.isEnabled()).isFalse();
assertThat(characteristicDto.getUpdatedAt()).isEqualTo(now);
-
- verify(ruleRegistry).reindex(ruleCaptor.getAllValues(), batchSession);
}
@Test
public void delete_characteristic() {
DbSession batchSession = mock(DbSession.class);
- when(mybatis.openSession(true)).thenReturn(batchSession);
+ when(dbClient.openSession(true)).thenReturn(batchSession);
- when(ruleDao.selectBySubCharacteristicId(subCharacteristicDto.getId(), batchSession)).thenReturn(newArrayList(
+ when(ruleDao.findRulesByDebtSubCharacteristicId(subCharacteristicDto.getId(), batchSession)).thenReturn(newArrayList(
new RuleDto().setSubCharacteristicId(subCharacteristicDto.getId())
.setRemediationFunction(DebtRemediationFunction.Type.LINEAR_OFFSET.toString())
.setRemediationCoefficient("2h")
assertThat(characteristicDto.getId()).isEqualTo(1);
assertThat(characteristicDto.isEnabled()).isFalse();
assertThat(characteristicDto.getUpdatedAt()).isEqualTo(now);
-
- verify(ruleRegistry).reindex(ruleCaptor.getAllValues(), batchSession);
}
@Test
public void not_delete_already_disabled_characteristic() {
DbSession batchSession = mock(DbSession.class);
- when(mybatis.openSession(true)).thenReturn(batchSession);
+ when(dbClient.openSession(true)).thenReturn(batchSession);
when(dao.selectById(1, batchSession)).thenReturn(new CharacteristicDto()
.setId(1)
@Test
public void find_by_ruleKey() throws Exception {
QualityProfileDto profile = QualityProfileDto.createFor("name","java");
- dbClient.getDao(QualityProfileDao.class).insert(profile, dbSession);
+ dbClient.qualityProfileDao().insert(profile, dbSession);
RuleDto rule = RuleDto.createFor(RuleKey.of("java", "r1"))
.setSeverity("MAJOR");
- dbClient.getDao(RuleDao.class).insert(rule, dbSession);
+ dbClient.ruleDao().insert(rule, dbSession);
RuleDto rule2 = RuleDto.createFor(RuleKey.of("java", "r2"))
.setSeverity("MAJOR");
- dbClient.getDao(RuleDao.class).insert(rule2, dbSession);
+ dbClient.ruleDao().insert(rule2, dbSession);
- dbClient.getDao(ActiveRuleDao.class).insert(
+ dbClient.activeRuleDao().insert(
ActiveRuleDto.createFor(profile, rule).setSeverity("MINOR"),
dbSession);
- dbClient.getDao(ActiveRuleDao.class).insert(
+ dbClient.activeRuleDao().insert(
ActiveRuleDto.createFor(profile, rule2).setSeverity("BLOCKER"),
dbSession);
import org.sonar.api.utils.System2;
import org.sonar.core.permission.GlobalPermissions;
import org.sonar.core.persistence.DbSession;
-import org.sonar.core.persistence.MyBatis;
-import org.sonar.core.rule.RuleDao;
import org.sonar.core.rule.RuleDto;
import org.sonar.core.technicaldebt.db.CharacteristicDao;
import org.sonar.core.technicaldebt.db.CharacteristicDto;
+import org.sonar.server.db.DbClient;
import org.sonar.server.exceptions.BadRequestException;
import org.sonar.server.exceptions.NotFoundException;
import org.sonar.server.rule.RuleOperations.RuleChange;
+import org.sonar.server.rule2.persistence.RuleDao;
import org.sonar.server.user.MockUserSession;
import org.sonar.server.user.UserSession;
public class RuleOperationsTest {
@Mock
- MyBatis myBatis;
+ DbClient dbClient;
@Mock
DbSession session;
@Mock
CharacteristicDao characteristicDao;
- @Mock
- RuleRegistry ruleRegistry;
-
- @Mock
- System2 system;
-
- Date now = DateUtils.parseDate("2014-03-19");
-
@Captor
ArgumentCaptor<RuleDto> ruleCaptor;
@Before
public void setUp() throws Exception {
- when(myBatis.openSession(false)).thenReturn(session);
-
- when(system.now()).thenReturn(now.getTime());
-
- operations = new RuleOperations(myBatis, ruleDao, characteristicDao, ruleRegistry, system);
+ when(dbClient.openSession(false)).thenReturn(session);
+ when(dbClient.ruleDao()).thenReturn(ruleDao);
+ when(dbClient.debtCharacteristicDao()).thenReturn(characteristicDao);
+ operations = new RuleOperations(dbClient);
}
@Test
.setSubCharacteristicId(6).setRemediationFunction("CONSTANT_ISSUE").setRemediationOffset("10min");
RuleKey ruleKey = RuleKey.of("squid", "UselessImportCheck");
- when(ruleDao.selectByKey(ruleKey, session)).thenReturn(dto);
+ when(ruleDao.getByKey(ruleKey, session)).thenReturn(dto);
CharacteristicDto subCharacteristic = new CharacteristicDto().setId(2).setKey("COMPILER").setName("Compiler").setParentId(1);
when(characteristicDao.selectByKey("COMPILER", session)).thenReturn(subCharacteristic);
);
verify(ruleDao).update(ruleCaptor.capture(), eq(session));
- verify(ruleRegistry).reindex(eq(ruleCaptor.getValue()), eq(session));
verify(session).commit();
RuleDto result = ruleCaptor.getValue();
assertThat(result.getRemediationFunction()).isEqualTo("LINEAR_OFFSET");
assertThat(result.getRemediationCoefficient()).isEqualTo("2h");
assertThat(result.getRemediationOffset()).isEqualTo("20min");
- assertThat(result.getUpdatedAt()).isEqualTo(now);
}
@Test
.setDefaultSubCharacteristicId(2).setDefaultRemediationFunction("CONSTANT_ISSUE").setDefaultRemediationOffset("10min");
RuleKey ruleKey = RuleKey.of("squid", "UselessImportCheck");
- when(ruleDao.selectByKey(ruleKey, session)).thenReturn(dto);
+ when(ruleDao.getByKey(ruleKey, session)).thenReturn(dto);
CharacteristicDto subCharacteristic = new CharacteristicDto().setId(2).setKey("COMPILER").setName("Compiler").setParentId(1);
when(characteristicDao.selectByKey("COMPILER", session)).thenReturn(subCharacteristic);
);
verify(ruleDao).update(ruleCaptor.capture(), eq(session));
- verify(ruleRegistry).reindex(eq(ruleCaptor.getValue()), eq(session));
verify(session).commit();
RuleDto result = ruleCaptor.getValue();
assertThat(result.getRemediationFunction()).isNull();
assertThat(result.getRemediationCoefficient()).isNull();
assertThat(result.getRemediationOffset()).isNull();
- assertThat(result.getUpdatedAt()).isEqualTo(now);
}
@Test
.setSubCharacteristicId(2).setRemediationFunction("CONSTANT_ISSUE").setRemediationOffset("10min");
RuleKey ruleKey = RuleKey.of("squid", "UselessImportCheck");
- when(ruleDao.selectByKey(ruleKey, session)).thenReturn(dto);
+ when(ruleDao.getByKey(ruleKey, session)).thenReturn(dto);
CharacteristicDto subCharacteristic = new CharacteristicDto().setId(2).setKey("COMPILER").setName("Compiler").setParentId(1);
when(characteristicDao.selectByKey("COMPILER", session)).thenReturn(subCharacteristic);
verify(ruleDao, never()).update(any(RuleDto.class), eq(session));
verify(session, never()).commit();
- verify(ruleRegistry, never()).reindex(any(RuleDto.class), eq(session));
}
@Test
.setDefaultSubCharacteristicId(2).setDefaultRemediationFunction("CONSTANT_ISSUE").setDefaultRemediationOffset("10min");
RuleKey ruleKey = RuleKey.of("squid", "UselessImportCheck");
- when(ruleDao.selectByKey(ruleKey, session)).thenReturn(dto);
+ when(ruleDao.getByKey(ruleKey, session)).thenReturn(dto);
CharacteristicDto subCharacteristic = new CharacteristicDto().setId(2).setKey("COMPILER").setName("Compiler").setParentId(1);
when(characteristicDao.selectByKey("COMPILER", session)).thenReturn(subCharacteristic);
);
verify(ruleDao).update(ruleCaptor.capture(), eq(session));
- verify(ruleRegistry).reindex(eq(ruleCaptor.getValue()), eq(session));
verify(session).commit();
RuleDto result = ruleCaptor.getValue();
assertThat(result.getRemediationFunction()).isEqualTo("LINEAR_OFFSET");
assertThat(result.getRemediationCoefficient()).isEqualTo("2h");
assertThat(result.getRemediationOffset()).isEqualTo("20min");
- assertThat(result.getUpdatedAt()).isEqualTo(now);
}
@Test
.setDefaultSubCharacteristicId(6).setDefaultRemediationFunction("CONSTANT_ISSUE").setDefaultRemediationOffset("10min");
RuleKey ruleKey = RuleKey.of("squid", "UselessImportCheck");
- when(ruleDao.selectByKey(ruleKey, session)).thenReturn(dto);
+ when(ruleDao.getByKey(ruleKey, session)).thenReturn(dto);
CharacteristicDto subCharacteristic = new CharacteristicDto().setId(2).setKey("COMPILER").setName("Compiler").setParentId(1);
when(characteristicDao.selectByKey("COMPILER", session)).thenReturn(subCharacteristic);
);
verify(ruleDao).update(ruleCaptor.capture(), eq(session));
- verify(ruleRegistry).reindex(eq(ruleCaptor.getValue()), eq(session));
verify(session).commit();
RuleDto result = ruleCaptor.getValue();
assertThat(result.getRemediationFunction()).isEqualTo("CONSTANT_ISSUE");
assertThat(result.getRemediationCoefficient()).isNull();
assertThat(result.getRemediationOffset()).isEqualTo("10min");
- assertThat(result.getUpdatedAt()).isEqualTo(now);
}
@Test
.setRemediationOffset("10min");
RuleKey ruleKey = RuleKey.of("squid", "UselessImportCheck");
- when(ruleDao.selectByKey(ruleKey, session)).thenReturn(dto);
+ when(ruleDao.getByKey(ruleKey, session)).thenReturn(dto);
operations.updateRule(new RuleChange().setRuleKey(ruleKey).setDebtCharacteristicKey(null), authorizedUserSession);
verify(ruleDao).update(ruleCaptor.capture(), eq(session));
- verify(ruleRegistry).reindex(eq(ruleCaptor.getValue()), eq(session));
verify(session).commit();
RuleDto result = ruleCaptor.getValue();
assertThat(result.getRemediationFunction()).isNull();
assertThat(result.getRemediationCoefficient()).isNull();
assertThat(result.getRemediationOffset()).isNull();
- assertThat(result.getUpdatedAt()).isEqualTo(now);
}
@Test
.setDefaultSubCharacteristicId(6).setDefaultRemediationFunction("CONSTANT_ISSUE").setDefaultRemediationOffset("10min");
RuleKey ruleKey = RuleKey.of("squid", "UselessImportCheck");
- when(ruleDao.selectByKey(ruleKey, session)).thenReturn(dto);
+ when(ruleDao.getByKey(ruleKey, session)).thenReturn(dto);
CharacteristicDto subCharacteristic = new CharacteristicDto().setId(2).setKey("COMPILER").setName("Compiler").setParentId(1);
when(characteristicDao.selectByKey("COMPILER", session)).thenReturn(subCharacteristic);
operations.updateRule(new RuleChange().setRuleKey(ruleKey).setDebtCharacteristicKey("COMPILER"), authorizedUserSession);
verify(ruleDao).update(ruleCaptor.capture(), eq(session));
- verify(ruleRegistry).reindex(eq(ruleCaptor.getValue()), eq(session));
verify(session).commit();
RuleDto result = ruleCaptor.getValue();
assertThat(result.getRemediationFunction()).isNull();
assertThat(result.getRemediationCoefficient()).isNull();
assertThat(result.getRemediationOffset()).isNull();
- assertThat(result.getUpdatedAt()).isEqualTo(now);
}
@Test
RuleDto dto = new RuleDto().setId(1).setRepositoryKey("squid").setRuleKey("UselessImportCheck");
RuleKey ruleKey = RuleKey.of("squid", "UselessImportCheck");
- when(ruleDao.selectByKey(ruleKey, session)).thenReturn(dto);
+ when(ruleDao.getByKey(ruleKey, session)).thenReturn(dto);
operations.updateRule(new RuleChange().setRuleKey(ruleKey).setDebtCharacteristicKey(null), authorizedUserSession);
verify(ruleDao).update(ruleCaptor.capture(), eq(session));
- verify(ruleRegistry).reindex(eq(ruleCaptor.getValue()), eq(session));
verify(session).commit();
RuleDto result = ruleCaptor.getValue();
assertThat(result.getRemediationFunction()).isNull();
assertThat(result.getRemediationCoefficient()).isNull();
assertThat(result.getRemediationOffset()).isNull();
- assertThat(result.getUpdatedAt()).isEqualTo(now);
}
@Test
RuleDto dto = new RuleDto().setId(1).setRepositoryKey("squid").setRuleKey("UselessImportCheck").setSubCharacteristicId(-1);
RuleKey ruleKey = RuleKey.of("squid", "UselessImportCheck");
- when(ruleDao.selectByKey(ruleKey, session)).thenReturn(dto);
+ when(ruleDao.getByKey(ruleKey, session)).thenReturn(dto);
operations.updateRule(
new RuleChange().setRuleKey(ruleKey).setDebtCharacteristicKey(null),
verify(ruleDao, never()).update(any(RuleDto.class), eq(session));
verify(session, never()).commit();
- verify(ruleRegistry, never()).reindex(any(RuleDto.class), eq(session));
}
@Test
public void fail_to_update_rule_on_unknown_rule() throws Exception {
RuleKey ruleKey = RuleKey.of("squid", "UselessImportCheck");
- when(ruleDao.selectByKey(ruleKey, session)).thenReturn(null);
+ when(ruleDao.getByKey(ruleKey, session)).thenReturn(null);
try {
operations.updateRule(
verify(ruleDao, never()).update(any(RuleDto.class), eq(session));
verify(session, never()).commit();
- verify(ruleRegistry, never()).reindex(any(RuleDto.class), eq(session));
}
@Test
.setSubCharacteristicId(2).setRemediationFunction("CONSTANT_ISSUE").setRemediationOffset("10min");
RuleKey ruleKey = RuleKey.of("squid", "UselessImportCheck");
- when(ruleDao.selectByKey(ruleKey, session)).thenReturn(dto);
+ when(ruleDao.getByKey(ruleKey, session)).thenReturn(dto);
when(characteristicDao.selectByKey("COMPILER", session)).thenReturn(null);
verify(ruleDao, never()).update(any(RuleDto.class), eq(session));
verify(session, never()).commit();
- verify(ruleRegistry, never()).reindex(any(RuleDto.class), eq(session));
}
@Test
.setSubCharacteristicId(2).setRemediationFunction("LINEAR").setRemediationCoefficient("1h");
RuleKey ruleKey = RuleKey.of("squid", "UselessImportCheck");
- when(ruleDao.selectByKey(ruleKey, session)).thenReturn(dto);
+ when(ruleDao.getByKey(ruleKey, session)).thenReturn(dto);
CharacteristicDto subCharacteristic = new CharacteristicDto().setId(2).setKey("COMPILER").setName("Compiler").setParentId(1);
when(characteristicDao.selectByKey("COMPILER", session)).thenReturn(subCharacteristic);
verify(ruleDao, never()).update(any(RuleDto.class), eq(session));
verify(session, never()).commit();
- verify(ruleRegistry, never()).reindex(any(RuleDto.class), eq(session));
}
}
assertThat(ruleDocument.get(RuleDocument.FIELD_REMEDIATION_OFFSET)).isNull();
}
- @Test
- public void remove_all_rules_when_ro_rule_registered() {
- String[] ids = registry.reindex(session);
- registry.removeDeletedRules(ids);
- assertThat(registry.findIds(new HashMap<String, String>())).hasSize(0);
- }
-
- @Test
- public void update_existing_rules_and_forget_deleted_rules() {
- when(ruleDao.selectEnablesAndNonManual(session)).thenReturn(newArrayList(
- new RuleDto().setId(1).setRepositoryKey("xoo").setRuleKey("key1").setSeverity(Severity.MINOR),
- new RuleDto().setId(2).setRepositoryKey("xoo").setRuleKey("key2").setSeverity(Severity.MINOR)
- ));
- assertThat(esSetup.exists("rules", "rule", "3")).isTrue();
-
- String[] ids = registry.reindex(session);
- registry.removeDeletedRules(ids);
-
- assertThat(registry.findIds(ImmutableMap.of("repositoryKey", "xoo")))
- .hasSize(2)
- .containsOnly(1, 2);
- assertThat(esSetup.exists("rules", "rule", "3")).isFalse();
- }
-
@Test
public void filter_removed_rules() {
assertThat(registry.findIds(new HashMap<String, String>())).containsOnly(1, 2, 3);
public void search_by_profile() throws InterruptedException {
QualityProfileDto qualityProfileDto1 = QualityProfileDto.createFor("profile1", "java");
QualityProfileDto qualityProfileDto2 = QualityProfileDto.createFor("profile2", "java");
- dbClient.getDao(QualityProfileDao.class).insert(qualityProfileDto1);
- dbClient.getDao(QualityProfileDao.class).insert(qualityProfileDto2);
+ dbClient.qualityProfileDao().insert(qualityProfileDto1);
+ dbClient.qualityProfileDao().insert(qualityProfileDto2);
RuleDto rule1 = newRuleDto(RuleKey.of("java", "S001"));
dao.insert(rule1, dbSession);
RuleDto rule3 = newRuleDto(RuleKey.of("java", "S003"));
dao.insert(rule3, dbSession);
- dbClient.getDao(ActiveRuleDao.class).insert(
+ dbClient.activeRuleDao().insert(
ActiveRuleDto.createFor(qualityProfileDto1, rule1)
.setSeverity("BLOCKER"), dbSession);
- dbClient.getDao(ActiveRuleDao.class).insert(
+ dbClient.activeRuleDao().insert(
ActiveRuleDto.createFor(qualityProfileDto2, rule1)
.setSeverity("BLOCKER"), dbSession);
- dbClient.getDao(ActiveRuleDao.class).insert(
+ dbClient.activeRuleDao().insert(
ActiveRuleDto.createFor(qualityProfileDto1, rule2)
.setSeverity("BLOCKER"), dbSession);
public void setUp() throws Exception {
DbClient dbClient = mock(DbClient.class);
when(dbClient.openSession(false)).thenReturn(session);
- when(dbClient.getDao(MeasureDao.class)).thenReturn(measureDao);
+ when(dbClient.measureDao()).thenReturn(measureDao);
service = new SourceService(dbClient, sourceDecorator, deprecatedSourceDecorator);
}
projects / sonarqube.git / commitdiff