From: Simon Brandhof Date: Wed, 21 May 2014 15:03:54 +0000 (+0200) Subject: SONAR-5007 improve usage of DbClient and move some services to new DAOs X-Git-Tag: 4.4-RC1~929 X-Git-Url: https://source.dussan.org/?a=commitdiff_plain;h=abcc0e27eaa842847e72f5d87a0d8bb2f4df2e56;p=sonarqube.git SONAR-5007 improve usage of DbClient and move some services to new DAOs --- diff --git a/sonar-core/src/main/java/org/sonar/api/DaoComponent.java b/sonar-core/src/main/java/org/sonar/api/DaoComponent.java deleted file mode 100644 index 8b200d93a7f..00000000000 --- a/sonar-core/src/main/java/org/sonar/api/DaoComponent.java +++ /dev/null @@ -1,26 +0,0 @@ -/* - * 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 { -} diff --git a/sonar-core/src/main/java/org/sonar/core/persistence/DaoComponent.java b/sonar-core/src/main/java/org/sonar/core/persistence/DaoComponent.java new file mode 100644 index 00000000000..da0a5f12224 --- /dev/null +++ b/sonar-core/src/main/java/org/sonar/core/persistence/DaoComponent.java @@ -0,0 +1,26 @@ +/* + * 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 { +} diff --git a/sonar-core/src/main/java/org/sonar/core/properties/PropertiesDao.java b/sonar-core/src/main/java/org/sonar/core/properties/PropertiesDao.java index 785416c5bad..be7e5ed7028 100644 --- a/sonar-core/src/main/java/org/sonar/core/properties/PropertiesDao.java +++ b/sonar-core/src/main/java/org/sonar/core/properties/PropertiesDao.java @@ -24,7 +24,7 @@ import com.google.common.base.Strings; 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; diff --git a/sonar-core/src/main/java/org/sonar/core/qualityprofile/db/QualityProfileDao.java b/sonar-core/src/main/java/org/sonar/core/qualityprofile/db/QualityProfileDao.java index 276b5dcfe19..5b975d5dcb2 100644 --- a/sonar-core/src/main/java/org/sonar/core/qualityprofile/db/QualityProfileDao.java +++ b/sonar-core/src/main/java/org/sonar/core/qualityprofile/db/QualityProfileDao.java @@ -22,7 +22,7 @@ package org.sonar.core.qualityprofile.db; 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; diff --git a/sonar-core/src/main/java/org/sonar/core/resource/ResourceDao.java b/sonar-core/src/main/java/org/sonar/core/resource/ResourceDao.java index 495c8f6acbd..e9475d79f48 100644 --- a/sonar-core/src/main/java/org/sonar/core/resource/ResourceDao.java +++ b/sonar-core/src/main/java/org/sonar/core/resource/ResourceDao.java @@ -23,7 +23,7 @@ import com.google.common.base.Function; 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; diff --git a/sonar-core/src/main/java/org/sonar/core/technicaldebt/db/CharacteristicDao.java b/sonar-core/src/main/java/org/sonar/core/technicaldebt/db/CharacteristicDao.java index 929a280598e..2eb94c33bd1 100644 --- a/sonar-core/src/main/java/org/sonar/core/technicaldebt/db/CharacteristicDao.java +++ b/sonar-core/src/main/java/org/sonar/core/technicaldebt/db/CharacteristicDao.java @@ -23,7 +23,7 @@ package org.sonar.core.technicaldebt.db; 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; diff --git a/sonar-core/src/main/java/org/sonar/core/template/LoadedTemplateDao.java b/sonar-core/src/main/java/org/sonar/core/template/LoadedTemplateDao.java index 126ab44bfd3..fc47e1f7517 100644 --- a/sonar-core/src/main/java/org/sonar/core/template/LoadedTemplateDao.java +++ b/sonar-core/src/main/java/org/sonar/core/template/LoadedTemplateDao.java @@ -21,7 +21,7 @@ package org.sonar.core.template; 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; diff --git a/sonar-server/src/main/java/org/sonar/server/component/persistence/ComponentDao.java b/sonar-server/src/main/java/org/sonar/server/component/persistence/ComponentDao.java index 8c77f4a440a..b72f9a286dc 100644 --- a/sonar-server/src/main/java/org/sonar/server/component/persistence/ComponentDao.java +++ b/sonar-server/src/main/java/org/sonar/server/component/persistence/ComponentDao.java @@ -21,7 +21,7 @@ package org.sonar.server.component.persistence; 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; diff --git a/sonar-server/src/main/java/org/sonar/server/component/ws/ComponentAppAction.java b/sonar-server/src/main/java/org/sonar/server/component/ws/ComponentAppAction.java index e18c1fb1f35..1eaa1bf2608 100644 --- a/sonar-server/src/main/java/org/sonar/server/component/ws/ComponentAppAction.java +++ b/sonar-server/src/main/java/org/sonar/server/component/ws/ComponentAppAction.java @@ -109,7 +109,7 @@ public class ComponentAppAction implements RequestHandler { 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)); } @@ -129,7 +129,7 @@ public class ComponentAppAction implements RequestHandler { } private void appendComponent(JsonWriter json, ComponentDto component, UserSession userSession, DbSession session) { - List propertyDtos = dbClient.getDao(PropertiesDao.class).selectByQuery(PropertyQuery.builder() + List propertyDtos = dbClient.propertiesDao().selectByQuery(PropertyQuery.builder() .setKey("favourite") .setComponentId(component.getId()) .setUserId(userSession.userId()) @@ -164,7 +164,7 @@ public class ComponentAppAction implements RequestHandler { private void appendMeasures(JsonWriter json, String fileKey, DbSession session) { json.name("measures").beginObject(); - List measures = dbClient.getDao(MeasureDao.class).findByComponentKeyAndMetricKeys(fileKey, + List 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 @@ -185,7 +185,7 @@ public class ComponentAppAction implements RequestHandler { 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); @@ -232,7 +232,7 @@ public class ComponentAppAction implements RequestHandler { @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; } diff --git a/sonar-server/src/main/java/org/sonar/server/db/BaseDao.java b/sonar-server/src/main/java/org/sonar/server/db/BaseDao.java index d50ee8711be..32042064b00 100644 --- a/sonar-server/src/main/java/org/sonar/server/db/BaseDao.java +++ b/sonar-server/src/main/java/org/sonar/server/db/BaseDao.java @@ -20,7 +20,7 @@ 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; diff --git a/sonar-server/src/main/java/org/sonar/server/db/DbClient.java b/sonar-server/src/main/java/org/sonar/server/db/DbClient.java index 15d2de0afe9..db78a373d38 100644 --- a/sonar-server/src/main/java/org/sonar/server/db/DbClient.java +++ b/sonar-server/src/main/java/org/sonar/server/db/DbClient.java @@ -19,16 +19,23 @@ */ 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; /** @@ -38,16 +45,35 @@ public class DbClient implements ServerComponent { private final Database db; private final MyBatis myBatis; - private final Map, 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, DaoComponent>(); - for(DaoComponent daoComponent : daoComponents){ - this.daoComponents.put(daoComponent.getClass(), daoComponent); + Map 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() { @@ -58,19 +84,47 @@ public class DbClient implements ServerComponent { return myBatis.openSession(batch); } - public K getDao(Class 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 getDao(Map map, Class clazz) { + return (K) map.get(clazz); } } diff --git a/sonar-server/src/main/java/org/sonar/server/debt/DebtModelBackup.java b/sonar-server/src/main/java/org/sonar/server/debt/DebtModelBackup.java index 2000feacf64..5eaa6a3077c 100644 --- a/sonar-server/src/main/java/org/sonar/server/debt/DebtModelBackup.java +++ b/sonar-server/src/main/java/org/sonar/server/debt/DebtModelBackup.java @@ -24,7 +24,6 @@ import com.google.common.base.Predicate; 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; @@ -38,21 +37,18 @@ 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.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; @@ -63,40 +59,34 @@ public class DebtModelBackup implements ServerComponent { 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; } @@ -112,10 +102,10 @@ public class DebtModelBackup implements ServerComponent { private String backupFromLanguage(@Nullable String languageKey) { checkPermission(); - SqlSession session = mybatis.openSession(false); + DbSession session = dbClient.openSession(false); try { DebtModel debtModel = new DebtModel(); - List characteristicDtos = dao.selectEnabledCharacteristics(session); + List characteristicDtos = dbClient.debtCharacteristicDao().selectEnabledCharacteristics(session); for (CharacteristicDto characteristicDto : characteristicDtos) { if (characteristicDto.getParentId() == null) { debtModel.addRootCharacteristic(toDebtCharacteristic(characteristicDto)); @@ -126,7 +116,7 @@ public class DebtModelBackup implements ServerComponent { } List 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) { @@ -147,13 +137,13 @@ public class DebtModelBackup implements ServerComponent { checkPermission(); Date updateDate = new Date(system2.now()); - DbSession session = mybatis.openSession(false); + DbSession session = dbClient.openSession(false); try { // Restore characteristics List allCharacteristicDtos = restoreCharacteristics(loadModelFromPlugin(DebtModelPluginRepository.DEFAULT_MODEL), updateDate, session); // Restore rules - List ruleDtos = ruleDao.selectEnablesAndNonManual(session); + List ruleDtos = dbClient.ruleDao().selectEnabledAndNonManual(session); if (!ruleDtos.isEmpty()) { // Load default rule definitions @@ -172,7 +162,7 @@ public class DebtModelBackup implements ServerComponent { } } - private void resetRules(List ruleDtos, List rules, List allCharacteristicDtos, Date updateDate, DbSession session){ + private void resetRules(List ruleDtos, List rules, List allCharacteristicDtos, Date updateDate, DbSession session) { for (RuleDto rule : ruleDtos) { // Restore default debt definitions @@ -202,9 +192,8 @@ public class DebtModelBackup implements ServerComponent { rule.setRemediationCoefficient(null); rule.setRemediationOffset(null); rule.setUpdatedAt(updateDate); - ruleDao.update(rule, session); + dbClient.ruleDao().update(rule, session); } - ruleRegistry.reindex(ruleDtos, session); } /** @@ -226,7 +215,7 @@ public class DebtModelBackup implements ServerComponent { ValidationMessages validationMessages = ValidationMessages.create(); Date updateDate = new Date(system2.now()); - DbSession session = mybatis.openSession(false); + DbSession session = dbClient.openSession(false); try { List allCharacteristicDtos = restoreCharacteristics(characteristicsXMLImporter.importXML(xml), updateDate, session); restoreRules(allCharacteristicDtos, rules(languageKey, session), rulesXMLImporter.importXML(xml, validationMessages), validationMessages, updateDate, session); @@ -254,7 +243,6 @@ public class DebtModelBackup implements ServerComponent { 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())); @@ -263,7 +251,7 @@ public class DebtModelBackup implements ServerComponent { @VisibleForTesting List restoreCharacteristics(DebtModel targetModel, Date updateDate, DbSession session) { - List sourceCharacteristics = dao.selectEnabledCharacteristics(session); + List sourceCharacteristics = dbClient.debtCharacteristicDao().selectEnabledCharacteristics(session); List result = newArrayList(); @@ -285,11 +273,11 @@ public class DebtModelBackup implements ServerComponent { } private CharacteristicDto restoreCharacteristic(DebtCharacteristic targetCharacteristic, @Nullable Integer parentId, List 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 @@ -300,7 +288,7 @@ public class DebtModelBackup implements ServerComponent { sourceCharacteristic.setOrder(targetCharacteristic.order()); sourceCharacteristic.setParentId(parentId); sourceCharacteristic.setUpdatedAt(updateDate); - dao.update(sourceCharacteristic, session); + dbClient.debtCharacteristicDao().update(sourceCharacteristic, session); } return sourceCharacteristic; } @@ -316,8 +304,8 @@ public class DebtModelBackup implements ServerComponent { } } - private List rules(@Nullable final String languageKey, SqlSession session) { - List rules = ruleDao.selectEnablesAndNonManual(session); + private List rules(@Nullable final String languageKey, DbSession session) { + List rules = dbClient.ruleDao().selectEnabledAndNonManual(session); if (languageKey == null) { return rules; } else { diff --git a/sonar-server/src/main/java/org/sonar/server/debt/DebtModelOperations.java b/sonar-server/src/main/java/org/sonar/server/debt/DebtModelOperations.java index cc4a6eace9e..d711ad7fe48 100644 --- a/sonar-server/src/main/java/org/sonar/server/debt/DebtModelOperations.java +++ b/sonar-server/src/main/java/org/sonar/server/debt/DebtModelOperations.java @@ -31,47 +31,38 @@ 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.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); @@ -90,9 +81,9 @@ public class DebtModelOperations implements ServerComponent { 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 { @@ -103,7 +94,7 @@ public class DebtModelOperations implements ServerComponent { public DebtCharacteristic rename(int characteristicId, String newName) { checkPermission(); - SqlSession session = mybatis.openSession(false); + SqlSession session = dbClient.openSession(false); try { checkNotAlreadyExists(newName, session); @@ -111,7 +102,7 @@ public class DebtModelOperations implements ServerComponent { 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); @@ -131,7 +122,7 @@ public class DebtModelOperations implements ServerComponent { 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) { @@ -148,11 +139,11 @@ public class DebtModelOperations implements ServerComponent { 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); @@ -161,8 +152,8 @@ public class DebtModelOperations implements ServerComponent { } } - 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())); } @@ -172,7 +163,7 @@ public class DebtModelOperations implements ServerComponent { @CheckForNull private CharacteristicDto findCharacteristicToSwitchWith(final CharacteristicDto dto, final boolean moveUpOrDown, SqlSession session) { // characteristics should be sort by 'order' - List rootCharacteristics = dao.selectEnabledRootCharacteristics(session); + List rootCharacteristics = dbClient.debtCharacteristicDao().selectEnabledRootCharacteristics(session); int currentPosition = Iterables.indexOf(rootCharacteristics, new Predicate() { @Override public boolean apply(@Nullable CharacteristicDto input) { @@ -191,7 +182,7 @@ public class DebtModelOperations implements ServerComponent { 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(); @@ -209,7 +200,7 @@ public class DebtModelOperations implements ServerComponent { 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 subCharacteristics = dao.selectCharacteristicsByParentId(characteristicOrSubCharacteristic.getId(), session); + List subCharacteristics = dbClient.debtCharacteristicDao().selectCharacteristicsByParentId(characteristicOrSubCharacteristic.getId(), session); for (CharacteristicDto subCharacteristic : subCharacteristics) { disableSubCharacteristic(subCharacteristic, updateDate, session); } @@ -223,14 +214,14 @@ public class DebtModelOperations implements ServerComponent { 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 ruleDtos, Integer subCharacteristicId, Date updateDate, DbSession session) { @@ -248,14 +239,12 @@ public class DebtModelOperations implements ServerComponent { 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)); } @@ -263,7 +252,7 @@ public class DebtModelOperations implements ServerComponent { } 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); } } diff --git a/sonar-server/src/main/java/org/sonar/server/measure/persistence/MeasureDao.java b/sonar-server/src/main/java/org/sonar/server/measure/persistence/MeasureDao.java index 5bf5fc6b94b..c77e87014e2 100644 --- a/sonar-server/src/main/java/org/sonar/server/measure/persistence/MeasureDao.java +++ b/sonar-server/src/main/java/org/sonar/server/measure/persistence/MeasureDao.java @@ -22,7 +22,7 @@ package org.sonar.server.measure.persistence; 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; diff --git a/sonar-server/src/main/java/org/sonar/server/qualityprofile/QualityProfileService.java b/sonar-server/src/main/java/org/sonar/server/qualityprofile/QualityProfileService.java index c4c470c340d..f31f144a26a 100644 --- a/sonar-server/src/main/java/org/sonar/server/qualityprofile/QualityProfileService.java +++ b/sonar-server/src/main/java/org/sonar/server/qualityprofile/QualityProfileService.java @@ -20,7 +20,6 @@ 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; @@ -33,11 +32,11 @@ public class QualityProfileService implements ServerComponent { private final DbClient dbClient; - public QualityProfileService(DbClient dbClient){ + public QualityProfileService(DbClient dbClient) { this.dbClient = dbClient; } public List findAll() { - return dbClient.getDao(QualityProfileDao.class).selectAll(); + return dbClient.qualityProfileDao().selectAll(); } } diff --git a/sonar-server/src/main/java/org/sonar/server/qualityprofile/RegisterQualityProfiles.java b/sonar-server/src/main/java/org/sonar/server/qualityprofile/RegisterQualityProfiles.java index 7c51baafbf0..21eb41f951f 100644 --- a/sonar-server/src/main/java/org/sonar/server/qualityprofile/RegisterQualityProfiles.java +++ b/sonar-server/src/main/java/org/sonar/server/qualityprofile/RegisterQualityProfiles.java @@ -31,7 +31,7 @@ import org.slf4j.LoggerFactory; 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; @@ -41,7 +41,6 @@ import org.sonar.core.qualityprofile.db.ActiveRuleDto; 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; @@ -135,11 +134,11 @@ public class RegisterQualityProfiles { 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; @@ -181,7 +180,7 @@ public class RegisterQualityProfiles { } } - dbClient.getDao(LoadedTemplateDao.class) + dbClient.loadedTemplateDao() .insert(new LoadedTemplateDto(templateKey(language, name), LoadedTemplateDto.QUALITY_PROFILE_TYPE), session); } @@ -248,7 +247,7 @@ public class RegisterQualityProfiles { } 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; } diff --git a/sonar-server/src/main/java/org/sonar/server/qualityprofile/index/ActiveRuleNormalizer.java b/sonar-server/src/main/java/org/sonar/server/qualityprofile/index/ActiveRuleNormalizer.java index e849104d5ab..de1592669b1 100644 --- a/sonar-server/src/main/java/org/sonar/server/qualityprofile/index/ActiveRuleNormalizer.java +++ b/sonar-server/src/main/java/org/sonar/server/qualityprofile/index/ActiveRuleNormalizer.java @@ -123,7 +123,7 @@ public class ActiveRuleNormalizer extends BaseNormalizer 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())); } @@ -96,7 +85,6 @@ public class RuleOperations implements ServerComponent { new Date(system.now()), session); if (needUpdate) { session.commit(); - reindexRule(ruleDto, session); } } catch (IllegalArgumentException e) { throw BadRequestException.of(e.getMessage()); @@ -144,8 +132,7 @@ public class RuleOperations implements ServerComponent { } if (needUpdate) { - ruleDto.setUpdatedAt(updateDate); - ruleDao.update(ruleDto, session); + dbClient.ruleDao().update(ruleDto, session); } return needUpdate; } @@ -172,10 +159,6 @@ public class RuleOperations implements ServerComponent { .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); diff --git a/sonar-server/src/main/java/org/sonar/server/rule/RuleRegistry.java b/sonar-server/src/main/java/org/sonar/server/rule/RuleRegistry.java index c5ee7c774b3..57ace078d02 100644 --- a/sonar-server/src/main/java/org/sonar/server/rule/RuleRegistry.java +++ b/sonar-server/src/main/java/org/sonar/server/rule/RuleRegistry.java @@ -112,7 +112,7 @@ public class RuleRegistry { } } - public String[] reindex(SqlSession session) { + String[] reindex(SqlSession session) { return reindex(ruleDao.selectEnablesAndNonManual(session), session); } @@ -154,7 +154,7 @@ public class RuleRegistry { /** * Reindex one rule */ - public void reindex(RuleDto rule) { + void reindex(RuleDto rule) { SqlSession sqlSession = myBatis.openSession(false); try { reindex(rule, sqlSession); @@ -207,16 +207,6 @@ public class RuleRegistry { } } - public void removeDeletedRules(String[] ids) { - List 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 params) throws IOException { XContentBuilder document = XContentFactory.jsonBuilder() diff --git a/sonar-server/src/main/java/org/sonar/server/rule2/RegisterRules.java b/sonar-server/src/main/java/org/sonar/server/rule2/RegisterRules.java index 69310f0beef..d8f09da5fe4 100644 --- a/sonar-server/src/main/java/org/sonar/server/rule2/RegisterRules.java +++ b/sonar-server/src/main/java/org/sonar/server/rule2/RegisterRules.java @@ -84,7 +84,7 @@ public class RegisterRules implements Startable { this.defLoader = defLoader; this.profilesManager = profilesManager; this.dbClient = dbClient; - this.characteristicDao = dbClient.getDao(CharacteristicDao.class); + this.characteristicDao = dbClient.debtCharacteristicDao(); } @Override @@ -280,7 +280,7 @@ public class RegisterRules implements Startable { // 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(RuleIndexDefinition.INDEX_TYPE, IndexAction.Method.UPDATE, paramDto, rule.getKey())); } diff --git a/sonar-server/src/main/java/org/sonar/server/rule2/persistence/RuleDao.java b/sonar-server/src/main/java/org/sonar/server/rule2/persistence/RuleDao.java index 27b809d283e..8cece78d6ec 100644 --- a/sonar-server/src/main/java/org/sonar/server/rule2/persistence/RuleDao.java +++ b/sonar-server/src/main/java/org/sonar/server/rule2/persistence/RuleDao.java @@ -169,4 +169,12 @@ public class RuleDao extends BaseDao { Preconditions.checkNotNull(rule.getId(), "Rule is not persisted"); return mapper(session).selectParamByRuleAndKey(rule.getId(), key); } + + public List findRulesByDebtSubCharacteristicId(int id, DbSession session) { + return mapper(session).selectBySubCharacteristicId(id); + } + + public List selectEnabledAndNonManual(DbSession session) { + return mapper(session).selectEnablesAndNonManual(); + } } diff --git a/sonar-server/src/main/java/org/sonar/server/source/SourceService.java b/sonar-server/src/main/java/org/sonar/server/source/SourceService.java index 4c975f3c0c8..b91bd7389d3 100644 --- a/sonar-server/src/main/java/org/sonar/server/source/SourceService.java +++ b/sonar-server/src/main/java/org/sonar/server/source/SourceService.java @@ -28,18 +28,15 @@ import org.sonar.core.measure.db.MeasureKey; 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; /** @@ -47,13 +44,10 @@ public class SourceService implements ServerComponent { */ 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 getLinesAsHtml(String fileKey) { @@ -83,7 +77,7 @@ public class SourceService implements ServerComponent { } 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) { @@ -104,7 +98,7 @@ public class SourceService implements ServerComponent { 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(); } diff --git a/sonar-server/src/test/java/org/sonar/server/component/ws/ComponentAppActionTest.java b/sonar-server/src/test/java/org/sonar/server/component/ws/ComponentAppActionTest.java index 6397c769309..b48ca55c535 100644 --- a/sonar-server/src/test/java/org/sonar/server/component/ws/ComponentAppActionTest.java +++ b/sonar-server/src/test/java/org/sonar/server/component/ws/ComponentAppActionTest.java @@ -106,10 +106,10 @@ public class ComponentAppActionTest { 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)); diff --git a/sonar-server/src/test/java/org/sonar/server/db/DbClientTest.java b/sonar-server/src/test/java/org/sonar/server/db/DbClientTest.java index ebbc386f16f..a9ab4d21df0 100644 --- a/sonar-server/src/test/java/org/sonar/server/db/DbClientTest.java +++ b/sonar-server/src/test/java/org/sonar/server/db/DbClientTest.java @@ -29,7 +29,6 @@ import org.sonar.server.qualityprofile.persistence.ActiveRuleDao; import org.sonar.server.rule2.persistence.RuleDao; import static org.fest.assertions.Assertions.assertThat; -import static org.mockito.Mockito.mock; public class DbClientTest { @@ -39,9 +38,9 @@ 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); @@ -52,8 +51,8 @@ public class DbClientTest { 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); } } diff --git a/sonar-server/src/test/java/org/sonar/server/debt/DebtModelBackupTest.java b/sonar-server/src/test/java/org/sonar/server/debt/DebtModelBackupTest.java index 8cf19f011bc..4a4419fe3fe 100644 --- a/sonar-server/src/test/java/org/sonar/server/debt/DebtModelBackupTest.java +++ b/sonar-server/src/test/java/org/sonar/server/debt/DebtModelBackupTest.java @@ -40,16 +40,15 @@ import org.sonar.api.utils.System2; 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; @@ -77,7 +76,7 @@ import static org.mockito.Mockito.when; public class DebtModelBackupTest { @Mock - MyBatis myBatis; + DbClient dbClient; @Mock DbSession session; @@ -106,9 +105,6 @@ public class DebtModelBackupTest { @Mock DebtModelXMLExporter debtModelXMLExporter; - @Mock - RuleRegistry ruleRegistry; - @Mock RuleDefinitionsLoader defLoader; @@ -148,13 +144,15 @@ public class DebtModelBackupTest { } }).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 @@ -164,7 +162,7 @@ public class DebtModelBackupTest { 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) @@ -210,7 +208,7 @@ public class DebtModelBackupTest { 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), @@ -232,7 +230,7 @@ public class DebtModelBackupTest { 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") @@ -270,7 +268,7 @@ public class DebtModelBackupTest { 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()) @@ -426,7 +424,7 @@ public class DebtModelBackupTest { 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()) @@ -455,10 +453,9 @@ public class DebtModelBackupTest { 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(); @@ -488,7 +485,7 @@ public class DebtModelBackupTest { 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()) @@ -515,10 +512,9 @@ public class DebtModelBackupTest { 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(); @@ -541,7 +537,7 @@ public class DebtModelBackupTest { 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) @@ -571,10 +567,9 @@ public class DebtModelBackupTest { 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); @@ -604,7 +599,7 @@ public class DebtModelBackupTest { new CharacteristicDto().setId(2).setKey("COMPILER").setName("Compiler updated").setParentId(1).setCreatedAt(oldDate) )); - when(ruleDao.selectEnablesAndNonManual(session)).thenReturn(Collections.emptyList()); + when(ruleDao.selectEnabledAndNonManual(session)).thenReturn(Collections.emptyList()); debtModelBackup.reset(); @@ -612,9 +607,8 @@ public class DebtModelBackupTest { 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(); @@ -637,7 +631,7 @@ public class DebtModelBackupTest { .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) @@ -647,8 +641,7 @@ public class DebtModelBackupTest { 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(); } @@ -662,7 +655,7 @@ public class DebtModelBackupTest { 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) @@ -672,8 +665,7 @@ public class DebtModelBackupTest { 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(); } @@ -691,7 +683,7 @@ public class DebtModelBackupTest { 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()) @@ -707,8 +699,7 @@ public class DebtModelBackupTest { 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(); } @@ -740,7 +731,7 @@ public class DebtModelBackupTest { )); when(rulesXMLImporter.importXML(anyString(), any(ValidationMessages.class))).thenReturn(Collections.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") @@ -754,8 +745,7 @@ public class DebtModelBackupTest { 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(); } @@ -772,14 +762,13 @@ public class DebtModelBackupTest { 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.emptyList()); + when(ruleDao.selectEnabledAndNonManual(session)).thenReturn(Collections.emptyList()); assertThat(debtModelBackup.restoreFromXml("").getWarnings()).hasSize(1); verifyZeroInteractions(ruleOperations); - verify(ruleDao).selectEnablesAndNonManual(session); - verify(ruleRegistry).reindex(ruleCaptor.getAllValues(), session); + verify(ruleDao).selectEnabledAndNonManual(session); verify(session).commit(); } @@ -796,7 +785,7 @@ public class DebtModelBackupTest { 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) @@ -806,8 +795,7 @@ public class DebtModelBackupTest { assertThat(debtModelBackup.restoreFromXml("").getErrors()).hasSize(1); - verify(ruleDao).selectEnablesAndNonManual(session); - verifyZeroInteractions(ruleRegistry); + verify(ruleDao).selectEnabledAndNonManual(session); verify(session, never()).commit(); } diff --git a/sonar-server/src/test/java/org/sonar/server/debt/DebtModelOperationsTest.java b/sonar-server/src/test/java/org/sonar/server/debt/DebtModelOperationsTest.java index 451c73493a5..cf3695f9cad 100644 --- a/sonar-server/src/test/java/org/sonar/server/debt/DebtModelOperationsTest.java +++ b/sonar-server/src/test/java/org/sonar/server/debt/DebtModelOperationsTest.java @@ -37,15 +37,14 @@ import org.sonar.api.utils.DateUtils; 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; @@ -72,14 +71,11 @@ public class DebtModelOperationsTest { RuleDao ruleDao; @Mock - MyBatis mybatis; + DbClient dbClient; @Mock DbSession session; - @Mock - RuleRegistry ruleRegistry; - @Mock System2 system2; @@ -126,8 +122,10 @@ public class DebtModelOperationsTest { } }).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 @@ -354,9 +352,9 @@ public class DebtModelOperationsTest { @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()) @@ -394,16 +392,14 @@ public class DebtModelOperationsTest { 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") @@ -414,7 +410,6 @@ public class DebtModelOperationsTest { 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(); @@ -435,16 +430,14 @@ public class DebtModelOperationsTest { 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") @@ -472,14 +465,12 @@ public class DebtModelOperationsTest { 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) diff --git a/sonar-server/src/test/java/org/sonar/server/qualityprofile/ActiveRuleServiceMediumTest.java b/sonar-server/src/test/java/org/sonar/server/qualityprofile/ActiveRuleServiceMediumTest.java index 1c90461cf1f..616db7de761 100644 --- a/sonar-server/src/test/java/org/sonar/server/qualityprofile/ActiveRuleServiceMediumTest.java +++ b/sonar-server/src/test/java/org/sonar/server/qualityprofile/ActiveRuleServiceMediumTest.java @@ -356,22 +356,22 @@ public class ActiveRuleServiceMediumTest { @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); diff --git a/sonar-server/src/test/java/org/sonar/server/rule/RuleOperationsTest.java b/sonar-server/src/test/java/org/sonar/server/rule/RuleOperationsTest.java index 3ec2db6300c..4b16bc5bbb9 100644 --- a/sonar-server/src/test/java/org/sonar/server/rule/RuleOperationsTest.java +++ b/sonar-server/src/test/java/org/sonar/server/rule/RuleOperationsTest.java @@ -32,14 +32,14 @@ import org.sonar.api.utils.DateUtils; 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; @@ -56,7 +56,7 @@ import static org.mockito.Mockito.when; public class RuleOperationsTest { @Mock - MyBatis myBatis; + DbClient dbClient; @Mock DbSession session; @@ -67,14 +67,6 @@ public class RuleOperationsTest { @Mock CharacteristicDao characteristicDao; - @Mock - RuleRegistry ruleRegistry; - - @Mock - System2 system; - - Date now = DateUtils.parseDate("2014-03-19"); - @Captor ArgumentCaptor ruleCaptor; @@ -84,11 +76,10 @@ public class RuleOperationsTest { @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 @@ -97,7 +88,7 @@ public class RuleOperationsTest { .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); @@ -114,7 +105,6 @@ public class RuleOperationsTest { ); verify(ruleDao).update(ruleCaptor.capture(), eq(session)); - verify(ruleRegistry).reindex(eq(ruleCaptor.getValue()), eq(session)); verify(session).commit(); RuleDto result = ruleCaptor.getValue(); @@ -124,7 +114,6 @@ public class RuleOperationsTest { assertThat(result.getRemediationFunction()).isEqualTo("LINEAR_OFFSET"); assertThat(result.getRemediationCoefficient()).isEqualTo("2h"); assertThat(result.getRemediationOffset()).isEqualTo("20min"); - assertThat(result.getUpdatedAt()).isEqualTo(now); } @Test @@ -134,7 +123,7 @@ public class RuleOperationsTest { .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); @@ -150,7 +139,6 @@ public class RuleOperationsTest { ); verify(ruleDao).update(ruleCaptor.capture(), eq(session)); - verify(ruleRegistry).reindex(eq(ruleCaptor.getValue()), eq(session)); verify(session).commit(); RuleDto result = ruleCaptor.getValue(); @@ -160,7 +148,6 @@ public class RuleOperationsTest { assertThat(result.getRemediationFunction()).isNull(); assertThat(result.getRemediationCoefficient()).isNull(); assertThat(result.getRemediationOffset()).isNull(); - assertThat(result.getUpdatedAt()).isEqualTo(now); } @Test @@ -169,7 +156,7 @@ public class RuleOperationsTest { .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); @@ -182,7 +169,6 @@ public class RuleOperationsTest { verify(ruleDao, never()).update(any(RuleDto.class), eq(session)); verify(session, never()).commit(); - verify(ruleRegistry, never()).reindex(any(RuleDto.class), eq(session)); } @Test @@ -191,7 +177,7 @@ public class RuleOperationsTest { .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); @@ -207,7 +193,6 @@ public class RuleOperationsTest { ); verify(ruleDao).update(ruleCaptor.capture(), eq(session)); - verify(ruleRegistry).reindex(eq(ruleCaptor.getValue()), eq(session)); verify(session).commit(); RuleDto result = ruleCaptor.getValue(); @@ -217,7 +202,6 @@ public class RuleOperationsTest { assertThat(result.getRemediationFunction()).isEqualTo("LINEAR_OFFSET"); assertThat(result.getRemediationCoefficient()).isEqualTo("2h"); assertThat(result.getRemediationOffset()).isEqualTo("20min"); - assertThat(result.getUpdatedAt()).isEqualTo(now); } @Test @@ -226,7 +210,7 @@ public class RuleOperationsTest { .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); @@ -242,7 +226,6 @@ public class RuleOperationsTest { ); verify(ruleDao).update(ruleCaptor.capture(), eq(session)); - verify(ruleRegistry).reindex(eq(ruleCaptor.getValue()), eq(session)); verify(session).commit(); RuleDto result = ruleCaptor.getValue(); @@ -252,7 +235,6 @@ public class RuleOperationsTest { assertThat(result.getRemediationFunction()).isEqualTo("CONSTANT_ISSUE"); assertThat(result.getRemediationCoefficient()).isNull(); assertThat(result.getRemediationOffset()).isEqualTo("10min"); - assertThat(result.getUpdatedAt()).isEqualTo(now); } @Test @@ -264,12 +246,11 @@ public class RuleOperationsTest { .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(); @@ -279,7 +260,6 @@ public class RuleOperationsTest { assertThat(result.getRemediationFunction()).isNull(); assertThat(result.getRemediationCoefficient()).isNull(); assertThat(result.getRemediationOffset()).isNull(); - assertThat(result.getUpdatedAt()).isEqualTo(now); } @Test @@ -288,7 +268,7 @@ public class RuleOperationsTest { .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); @@ -299,7 +279,6 @@ public class RuleOperationsTest { 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(); @@ -309,7 +288,6 @@ public class RuleOperationsTest { assertThat(result.getRemediationFunction()).isNull(); assertThat(result.getRemediationCoefficient()).isNull(); assertThat(result.getRemediationOffset()).isNull(); - assertThat(result.getUpdatedAt()).isEqualTo(now); } @Test @@ -317,12 +295,11 @@ public class RuleOperationsTest { 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(); @@ -332,7 +309,6 @@ public class RuleOperationsTest { assertThat(result.getRemediationFunction()).isNull(); assertThat(result.getRemediationCoefficient()).isNull(); assertThat(result.getRemediationOffset()).isNull(); - assertThat(result.getUpdatedAt()).isEqualTo(now); } @Test @@ -340,7 +316,7 @@ public class RuleOperationsTest { 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), @@ -349,14 +325,13 @@ public class RuleOperationsTest { 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( @@ -370,7 +345,6 @@ public class RuleOperationsTest { verify(ruleDao, never()).update(any(RuleDto.class), eq(session)); verify(session, never()).commit(); - verify(ruleRegistry, never()).reindex(any(RuleDto.class), eq(session)); } @Test @@ -379,7 +353,7 @@ public class RuleOperationsTest { .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); @@ -395,7 +369,6 @@ public class RuleOperationsTest { verify(ruleDao, never()).update(any(RuleDto.class), eq(session)); verify(session, never()).commit(); - verify(ruleRegistry, never()).reindex(any(RuleDto.class), eq(session)); } @Test @@ -404,7 +377,7 @@ public class RuleOperationsTest { .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); @@ -421,6 +394,5 @@ public class RuleOperationsTest { verify(ruleDao, never()).update(any(RuleDto.class), eq(session)); verify(session, never()).commit(); - verify(ruleRegistry, never()).reindex(any(RuleDto.class), eq(session)); } } diff --git a/sonar-server/src/test/java/org/sonar/server/rule/RuleRegistryTest.java b/sonar-server/src/test/java/org/sonar/server/rule/RuleRegistryTest.java index 6087f6ac164..c15a1a17b2f 100644 --- a/sonar-server/src/test/java/org/sonar/server/rule/RuleRegistryTest.java +++ b/sonar-server/src/test/java/org/sonar/server/rule/RuleRegistryTest.java @@ -334,30 +334,6 @@ public class RuleRegistryTest { 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())).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())).containsOnly(1, 2, 3); diff --git a/sonar-server/src/test/java/org/sonar/server/rule2/index/RuleIndexMediumTest.java b/sonar-server/src/test/java/org/sonar/server/rule2/index/RuleIndexMediumTest.java index 18e72e7df8f..22afd0a2dea 100644 --- a/sonar-server/src/test/java/org/sonar/server/rule2/index/RuleIndexMediumTest.java +++ b/sonar-server/src/test/java/org/sonar/server/rule2/index/RuleIndexMediumTest.java @@ -371,8 +371,8 @@ public class RuleIndexMediumTest { 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); @@ -381,15 +381,15 @@ public class RuleIndexMediumTest { 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); diff --git a/sonar-server/src/test/java/org/sonar/server/source/SourceServiceTest.java b/sonar-server/src/test/java/org/sonar/server/source/SourceServiceTest.java index 0321ebc0524..7f13a2aba26 100644 --- a/sonar-server/src/test/java/org/sonar/server/source/SourceServiceTest.java +++ b/sonar-server/src/test/java/org/sonar/server/source/SourceServiceTest.java @@ -64,7 +64,7 @@ public class SourceServiceTest { 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); }