import org.sonar.server.permission.InternalPermissionTemplateService;
import org.sonar.server.permission.PermissionFinder;
import org.sonar.server.plugins.*;
-import org.sonar.server.qualityprofile.QProfileOperations;
-import org.sonar.server.qualityprofile.QProfileProjectService;
-import org.sonar.server.qualityprofile.QProfileSearch;
-import org.sonar.server.qualityprofile.QProfiles;
+import org.sonar.server.qualityprofile.*;
import org.sonar.server.rule.ProfileRules;
import org.sonar.server.rule.RubyRuleService;
import org.sonar.server.rule.RuleRegistry;
servicesContainer.addSingleton(QProfiles.class);
servicesContainer.addSingleton(QProfileSearch.class);
servicesContainer.addSingleton(QProfileOperations.class);
+ servicesContainer.addSingleton(QProfileActiveRuleOperations.class);
+ servicesContainer.addSingleton(QProfileRuleOperations.class);
servicesContainer.addSingleton(QProfileProjectService.class);
// users
--- /dev/null
+/*
+ * SonarQube, open source software quality management tool.
+ * Copyright (C) 2008-2013 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.server.qualityprofile;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Strings;
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Multimap;
+import org.apache.commons.lang.math.NumberUtils;
+import org.apache.ibatis.session.SqlSession;
+import org.sonar.api.PropertyType;
+import org.sonar.api.ServerComponent;
+import org.sonar.api.rule.Severity;
+import org.sonar.api.rules.RulePriority;
+import org.sonar.api.utils.System2;
+import org.sonar.core.permission.GlobalPermissions;
+import org.sonar.core.persistence.MyBatis;
+import org.sonar.core.preview.PreviewCache;
+import org.sonar.core.qualityprofile.db.ActiveRuleDao;
+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.RuleDao;
+import org.sonar.core.rule.RuleDto;
+import org.sonar.core.rule.RuleParamDto;
+import org.sonar.server.configuration.ProfilesManager;
+import org.sonar.server.exceptions.BadRequestException;
+import org.sonar.server.rule.RuleRegistry;
+import org.sonar.server.user.UserSession;
+
+import java.util.Date;
+import java.util.List;
+
+public class QProfileActiveRuleOperations implements ServerComponent {
+
+ private final MyBatis myBatis;
+ private final ActiveRuleDao activeRuleDao;
+ private final RuleDao ruleDao;
+ private final PreviewCache dryRunCache;
+ private final RuleRegistry ruleRegistry;
+ private final ProfilesManager profilesManager;
+
+ private final System2 system;
+
+ public QProfileActiveRuleOperations(MyBatis myBatis, ActiveRuleDao activeRuleDao, RuleDao ruleDao, PreviewCache dryRunCache, RuleRegistry ruleRegistry, ProfilesManager profilesManager) {
+ this(myBatis, activeRuleDao, ruleDao, dryRunCache, ruleRegistry,
+ profilesManager, System2.INSTANCE);
+ }
+
+ @VisibleForTesting
+ QProfileActiveRuleOperations(MyBatis myBatis, ActiveRuleDao activeRuleDao, RuleDao ruleDao, PreviewCache dryRunCache, RuleRegistry ruleRegistry,
+ ProfilesManager profilesManager, System2 system) {
+ this.myBatis = myBatis;
+ this.activeRuleDao = activeRuleDao;
+ this.ruleDao = ruleDao;
+ this.dryRunCache = dryRunCache;
+ this.ruleRegistry = ruleRegistry;
+ this.profilesManager = profilesManager;
+ this.system = system;
+ }
+
+ public ActiveRuleDto createActiveRule(QualityProfileDto qualityProfile, RuleDto rule, String severity, UserSession userSession) {
+ checkPermission(userSession);
+ checkSeverity(severity);
+ SqlSession session = myBatis.openSession();
+ try {
+ ActiveRuleDto activeRule = new ActiveRuleDto()
+ .setProfileId(qualityProfile.getId())
+ .setRuleId(rule.getId())
+ .setSeverity(Severity.ordinal(severity));
+ activeRuleDao.insert(activeRule, session);
+
+ List<RuleParamDto> ruleParams = ruleDao.selectParameters(rule.getId(), session);
+ List<ActiveRuleParamDto> activeRuleParams = Lists.newArrayList();
+ for (RuleParamDto ruleParam : ruleParams) {
+ ActiveRuleParamDto activeRuleParam = new ActiveRuleParamDto()
+ .setActiveRuleId(activeRule.getId())
+ .setRulesParameterId(ruleParam.getId())
+ .setKey(ruleParam.getName())
+ .setValue(ruleParam.getDefaultValue());
+ activeRuleParams.add(activeRuleParam);
+ activeRuleDao.insert(activeRuleParam, session);
+ }
+ session.commit();
+
+ RuleInheritanceActions actions = profilesManager.activated(qualityProfile.getId(), activeRule.getId(), userSession.name());
+ reindexInheritanceResult(actions, session);
+
+ return activeRule;
+ } finally {
+ MyBatis.closeQuietly(session);
+ }
+ }
+
+ public void updateSeverity(ActiveRuleDto activeRule, String newSeverity, UserSession userSession) {
+ checkPermission(userSession);
+ checkSeverity(newSeverity);
+ SqlSession session = myBatis.openSession();
+ try {
+ Integer oldSeverity = activeRule.getSeverity();
+ activeRule.setSeverity(Severity.ordinal(newSeverity));
+ activeRuleDao.update(activeRule, session);
+ session.commit();
+
+ RuleInheritanceActions actions = profilesManager.ruleSeverityChanged(activeRule.getProfileId(), activeRule.getId(),
+ RulePriority.valueOfInt(oldSeverity), RulePriority.valueOf(newSeverity),
+ userSession.name());
+ reindexInheritanceResult(actions, session);
+ } finally {
+ MyBatis.closeQuietly(session);
+ }
+ }
+
+ public void deactivateRule(ActiveRuleDto activeRule, UserSession userSession) {
+ checkPermission(userSession);
+
+ SqlSession session = myBatis.openSession();
+ try {
+ RuleInheritanceActions actions = profilesManager.deactivated(activeRule.getProfileId(), activeRule.getId(), userSession.name());
+
+ activeRuleDao.deleteParameters(activeRule.getId(), session);
+ activeRuleDao.delete(activeRule.getId(), session);
+ actions.addToDelete(activeRule.getId());
+ session.commit();
+
+ reindexInheritanceResult(actions, session);
+ } finally {
+ MyBatis.closeQuietly(session);
+ }
+ }
+
+ public void createActiveRuleParam(ActiveRuleDto activeRule, String key, String value, UserSession userSession) {
+ checkPermission(userSession);
+
+ SqlSession session = myBatis.openSession();
+ try {
+ RuleParamDto ruleParam = findRuleParamNotNull(activeRule.getRulId(), key, session);
+ validateParam(ruleParam.getType(), value);
+ ActiveRuleParamDto activeRuleParam = new ActiveRuleParamDto().setActiveRuleId(activeRule.getId()).setKey(key).setValue(value).setRulesParameterId(ruleParam.getId());
+ activeRuleDao.insert(activeRuleParam, session);
+ session.commit();
+
+ RuleInheritanceActions actions = profilesManager.ruleParamChanged(activeRule.getProfileId(), activeRule.getId(), key, null, value, userSession.name());
+ reindexInheritanceResult(actions, session);
+ } finally {
+ MyBatis.closeQuietly(session);
+ }
+ }
+
+ public void deleteActiveRuleParam(ActiveRuleDto activeRule, ActiveRuleParamDto activeRuleParam, UserSession userSession) {
+ checkPermission(userSession);
+
+ SqlSession session = myBatis.openSession();
+ try {
+ activeRuleDao.deleteParameter(activeRuleParam.getId(), session);
+ session.commit();
+
+ RuleInheritanceActions actions = profilesManager.ruleParamChanged(activeRule.getProfileId(), activeRule.getId(), activeRuleParam.getKey(), activeRuleParam.getValue(),
+ null, userSession.name());
+ reindexInheritanceResult(actions, session);
+ } finally {
+ MyBatis.closeQuietly(session);
+ }
+ }
+
+ public void updateActiveRuleParam(ActiveRuleDto activeRule, ActiveRuleParamDto activeRuleParam, String value, UserSession userSession) {
+ checkPermission(userSession);
+
+ SqlSession session = myBatis.openSession();
+ try {
+ RuleParamDto ruleParam = findRuleParamNotNull(activeRule.getRulId(), activeRuleParam.getKey(), session);
+ validateParam(ruleParam.getType(), value);
+
+ String sanitizedValue = Strings.emptyToNull(value);
+ String oldValue = activeRuleParam.getValue();
+ activeRuleParam.setValue(sanitizedValue);
+ activeRuleDao.update(activeRuleParam, session);
+ session.commit();
+
+ RuleInheritanceActions actions = profilesManager.ruleParamChanged(activeRule.getProfileId(), activeRule.getId(), activeRuleParam.getKey(), oldValue,
+ sanitizedValue, getLoggedName(userSession));
+ reindexInheritanceResult(actions, session);
+ } finally {
+ MyBatis.closeQuietly(session);
+ }
+ }
+
+ public void updateActiveRuleNote(ActiveRuleDto activeRule, String note, UserSession userSession) {
+ checkPermission(userSession);
+ Date now = new Date(system.now());
+ SqlSession session = myBatis.openSession();
+ try {
+ if (activeRule.getNoteData() == null) {
+ activeRule.setNoteCreatedAt(now);
+ activeRule.setNoteUserLogin(userSession.login());
+ }
+ activeRule.setNoteUpdatedAt(now);
+ activeRule.setNoteData(note);
+ activeRuleDao.update(activeRule, session);
+ session.commit();
+
+ reindexActiveRule(activeRule, session);
+ } finally {
+ MyBatis.closeQuietly(session);
+ }
+ }
+
+ public void deleteActiveRuleNote(ActiveRuleDto activeRule, UserSession userSession) {
+ checkPermission(userSession);
+
+ SqlSession session = myBatis.openSession();
+ try {
+ activeRule.setNoteData(null);
+ activeRule.setNoteUserLogin(null);
+ activeRule.setNoteCreatedAt(null);
+ activeRule.setNoteUpdatedAt(null);
+ activeRuleDao.update(activeRule);
+ session.commit();
+
+ reindexActiveRule(activeRule, session);
+ } finally {
+ MyBatis.closeQuietly(session);
+ }
+ }
+
+ private void reindexInheritanceResult(RuleInheritanceActions actions, SqlSession session) {
+ ruleRegistry.deleteActiveRules(actions.idsToDelete());
+ List<ActiveRuleDto> activeRules = activeRuleDao.selectByIds(actions.idsToIndex(), session);
+ Multimap<Integer, ActiveRuleParamDto> paramsByActiveRule = ArrayListMultimap.create();
+ for (ActiveRuleParamDto param : activeRuleDao.selectParamsByActiveRuleIds(actions.idsToIndex(), session)) {
+ paramsByActiveRule.put(param.getActiveRuleId(), param);
+ }
+ ruleRegistry.bulkIndexActiveRules(activeRules, paramsByActiveRule);
+ }
+
+ private void reindexActiveRule(ActiveRuleDto activeRuleDto, SqlSession session) {
+ ruleRegistry.save(activeRuleDto, activeRuleDao.selectParamsByActiveRuleId(activeRuleDto.getId(), session));
+ }
+
+ private void checkPermission(UserSession userSession) {
+ userSession.checkLoggedIn();
+ userSession.checkGlobalPermission(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ }
+
+ private String getLoggedName(UserSession userSession) {
+ String name = userSession.name();
+ if (Strings.isNullOrEmpty(name)) {
+ throw new BadRequestException("User name can't be null");
+ }
+ return name;
+ }
+
+ private void checkSeverity(String severity) {
+ if (!Severity.ALL.contains(severity)) {
+ throw new BadRequestException("The severity is not valid");
+ }
+ }
+
+ private RuleParamDto findRuleParamNotNull(Integer ruleId, String key, SqlSession session) {
+ RuleParamDto ruleParam = ruleDao.selectParamByRuleAndKey(ruleId, key, session);
+ if (ruleParam == null) {
+ throw new IllegalArgumentException("No rule param found");
+ }
+ return ruleParam;
+ }
+
+ private void validateParam(String type, String value) {
+ if (type.equals(PropertyType.INTEGER.name()) && !NumberUtils.isDigits(value)) {
+ throw new BadRequestException(String.format("Value '%s' must be an integer.", value));
+ }
+ }
+
+}
package org.sonar.server.qualityprofile;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Function;
-import com.google.common.base.Strings;
import com.google.common.collect.ArrayListMultimap;
-import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import com.google.common.collect.Multimap;
import org.apache.commons.lang.StringUtils;
-import org.apache.commons.lang.math.NumberUtils;
import org.apache.ibatis.session.SqlSession;
-import org.sonar.api.PropertyType;
import org.sonar.api.ServerComponent;
import org.sonar.api.profiles.ProfileImporter;
import org.sonar.api.profiles.RulesProfile;
-import org.sonar.api.rule.Severity;
import org.sonar.api.rules.ActiveRule;
import org.sonar.api.rules.ActiveRuleParam;
-import org.sonar.api.rules.Rule;
import org.sonar.api.rules.RulePriority;
import org.sonar.api.utils.System2;
import org.sonar.api.utils.ValidationMessages;
-import org.sonar.check.Cardinality;
import org.sonar.core.permission.GlobalPermissions;
import org.sonar.core.persistence.MyBatis;
import org.sonar.core.preview.PreviewCache;
import org.sonar.core.properties.PropertyDto;
import org.sonar.core.qualityprofile.db.*;
import org.sonar.core.rule.RuleDao;
-import org.sonar.core.rule.RuleDto;
-import org.sonar.core.rule.RuleParamDto;
-import org.sonar.server.configuration.ProfilesManager;
import org.sonar.server.exceptions.BadRequestException;
import org.sonar.server.rule.RuleRegistry;
import org.sonar.server.user.UserSession;
import java.io.StringReader;
-import java.util.Date;
import java.util.List;
import java.util.Map;
private final List<ProfileImporter> importers;
private final PreviewCache dryRunCache;
private final RuleRegistry ruleRegistry;
- private final ProfilesManager profilesManager;
private final System2 system;
* Used by pico when no plugin provide profile exporter / importer
*/
public QProfileOperations(MyBatis myBatis, QualityProfileDao dao, ActiveRuleDao activeRuleDao, RuleDao ruleDao, PropertiesDao propertiesDao,
- PreviewCache dryRunCache, RuleRegistry ruleRegistry, ProfilesManager profilesManager) {
- this(myBatis, dao, activeRuleDao, ruleDao, propertiesDao, Lists.<ProfileImporter>newArrayList(), dryRunCache, ruleRegistry,
- profilesManager, System2.INSTANCE);
+ PreviewCache dryRunCache, RuleRegistry ruleRegistry) {
+ this(myBatis, dao, activeRuleDao, ruleDao, propertiesDao, Lists.<ProfileImporter>newArrayList(), dryRunCache, ruleRegistry, System2.INSTANCE);
}
public QProfileOperations(MyBatis myBatis, QualityProfileDao dao, ActiveRuleDao activeRuleDao, RuleDao ruleDao, PropertiesDao propertiesDao,
- List<ProfileImporter> importers, PreviewCache dryRunCache, RuleRegistry ruleRegistry, ProfilesManager profilesManager) {
- this(myBatis, dao, activeRuleDao, ruleDao, propertiesDao, importers, dryRunCache, ruleRegistry,
- profilesManager, System2.INSTANCE);
+ List<ProfileImporter> importers, PreviewCache dryRunCache, RuleRegistry ruleRegistry) {
+ this(myBatis, dao, activeRuleDao, ruleDao, propertiesDao, importers, dryRunCache, ruleRegistry, System2.INSTANCE);
}
@VisibleForTesting
QProfileOperations(MyBatis myBatis, QualityProfileDao dao, ActiveRuleDao activeRuleDao, RuleDao ruleDao, PropertiesDao propertiesDao,
- List<ProfileImporter> importers, PreviewCache dryRunCache, RuleRegistry ruleRegistry,
- ProfilesManager profilesManager, System2 system) {
+ List<ProfileImporter> importers, PreviewCache dryRunCache, RuleRegistry ruleRegistry, System2 system) {
this.myBatis = myBatis;
this.dao = dao;
this.activeRuleDao = activeRuleDao;
this.importers = importers;
this.dryRunCache = dryRunCache;
this.ruleRegistry = ruleRegistry;
- this.profilesManager = profilesManager;
this.system = system;
}
propertiesDao.setProperty(new PropertyDto().setKey(PROPERTY_PREFIX + qualityProfile.getLanguage()).setValue(qualityProfile.getName()));
}
- public ActiveRuleDto createActiveRule(QualityProfileDto qualityProfile, RuleDto rule, String severity, UserSession userSession) {
- checkPermission(userSession);
- checkSeverity(severity);
- SqlSession session = myBatis.openSession();
- try {
- ActiveRuleDto activeRule = new ActiveRuleDto()
- .setProfileId(qualityProfile.getId())
- .setRuleId(rule.getId())
- .setSeverity(Severity.ordinal(severity));
- activeRuleDao.insert(activeRule, session);
-
- List<RuleParamDto> ruleParams = ruleDao.selectParameters(rule.getId(), session);
- List<ActiveRuleParamDto> activeRuleParams = Lists.newArrayList();
- for (RuleParamDto ruleParam : ruleParams) {
- ActiveRuleParamDto activeRuleParam = new ActiveRuleParamDto()
- .setActiveRuleId(activeRule.getId())
- .setRulesParameterId(ruleParam.getId())
- .setKey(ruleParam.getName())
- .setValue(ruleParam.getDefaultValue());
- activeRuleParams.add(activeRuleParam);
- activeRuleDao.insert(activeRuleParam, session);
- }
- session.commit();
-
- RuleInheritanceActions actions = profilesManager.activated(qualityProfile.getId(), activeRule.getId(), userSession.name());
- reindexInheritanceResult(actions, session);
-
- return activeRule;
- } finally {
- MyBatis.closeQuietly(session);
- }
- }
-
- public void updateSeverity(ActiveRuleDto activeRule, String newSeverity, UserSession userSession) {
- checkPermission(userSession);
- checkSeverity(newSeverity);
- SqlSession session = myBatis.openSession();
- try {
- Integer oldSeverity = activeRule.getSeverity();
- activeRule.setSeverity(Severity.ordinal(newSeverity));
- activeRuleDao.update(activeRule, session);
- session.commit();
-
- RuleInheritanceActions actions = profilesManager.ruleSeverityChanged(activeRule.getProfileId(), activeRule.getId(),
- RulePriority.valueOfInt(oldSeverity), RulePriority.valueOf(newSeverity),
- userSession.name());
- reindexInheritanceResult(actions, session);
- } finally {
- MyBatis.closeQuietly(session);
- }
- }
-
- public void deactivateRule(ActiveRuleDto activeRule, UserSession userSession) {
- checkPermission(userSession);
-
- SqlSession session = myBatis.openSession();
- try {
- RuleInheritanceActions actions = profilesManager.deactivated(activeRule.getProfileId(), activeRule.getId(), userSession.name());
-
- activeRuleDao.deleteParameters(activeRule.getId(), session);
- activeRuleDao.delete(activeRule.getId(), session);
- actions.addToDelete(activeRule.getId());
- session.commit();
-
- reindexInheritanceResult(actions, session);
- } finally {
- MyBatis.closeQuietly(session);
- }
- }
-
- public void createActiveRuleParam(ActiveRuleDto activeRule, String key, String value, UserSession userSession) {
- checkPermission(userSession);
-
- SqlSession session = myBatis.openSession();
- try {
- RuleParamDto ruleParam = findRuleParamNotNull(activeRule.getRulId(), key, session);
- validateParam(ruleParam.getType(), value);
- ActiveRuleParamDto activeRuleParam = new ActiveRuleParamDto().setActiveRuleId(activeRule.getId()).setKey(key).setValue(value).setRulesParameterId(ruleParam.getId());
- activeRuleDao.insert(activeRuleParam, session);
- session.commit();
-
- RuleInheritanceActions actions = profilesManager.ruleParamChanged(activeRule.getProfileId(), activeRule.getId(), key, null, value, userSession.name());
- reindexInheritanceResult(actions, session);
- } finally {
- MyBatis.closeQuietly(session);
- }
- }
-
- public void deleteActiveRuleParam(ActiveRuleDto activeRule, ActiveRuleParamDto activeRuleParam, UserSession userSession) {
- checkPermission(userSession);
-
- SqlSession session = myBatis.openSession();
- try {
- activeRuleDao.deleteParameter(activeRuleParam.getId(), session);
- session.commit();
-
- RuleInheritanceActions actions = profilesManager.ruleParamChanged(activeRule.getProfileId(), activeRule.getId(), activeRuleParam.getKey(), activeRuleParam.getValue(),
- null, userSession.name());
- reindexInheritanceResult(actions, session);
- } finally {
- MyBatis.closeQuietly(session);
- }
- }
-
- public void updateActiveRuleParam(ActiveRuleDto activeRule, ActiveRuleParamDto activeRuleParam, String value, UserSession userSession) {
- checkPermission(userSession);
-
- SqlSession session = myBatis.openSession();
- try {
- RuleParamDto ruleParam = findRuleParamNotNull(activeRule.getRulId(), activeRuleParam.getKey(), session);
- validateParam(ruleParam.getType(), value);
-
- String sanitizedValue = Strings.emptyToNull(value);
- String oldValue = activeRuleParam.getValue();
- activeRuleParam.setValue(sanitizedValue);
- activeRuleDao.update(activeRuleParam, session);
- session.commit();
-
- RuleInheritanceActions actions = profilesManager.ruleParamChanged(activeRule.getProfileId(), activeRule.getId(), activeRuleParam.getKey(), oldValue,
- sanitizedValue, getLoggedName(userSession));
- reindexInheritanceResult(actions, session);
- } finally {
- MyBatis.closeQuietly(session);
- }
- }
-
- public void updateActiveRuleNote(ActiveRuleDto activeRule, String note, UserSession userSession) {
- checkPermission(userSession);
- Date now = new Date(system.now());
- SqlSession session = myBatis.openSession();
- try {
- if (activeRule.getNoteData() == null) {
- activeRule.setNoteCreatedAt(now);
- activeRule.setNoteUserLogin(userSession.login());
- }
- activeRule.setNoteUpdatedAt(now);
- activeRule.setNoteData(note);
- activeRuleDao.update(activeRule, session);
- session.commit();
-
- reindexActiveRule(activeRule, session);
- } finally {
- MyBatis.closeQuietly(session);
- }
- }
-
- public void deleteActiveRuleNote(ActiveRuleDto activeRule, UserSession userSession) {
- checkPermission(userSession);
-
- SqlSession session = myBatis.openSession();
- try {
- activeRule.setNoteData(null);
- activeRule.setNoteUserLogin(null);
- activeRule.setNoteCreatedAt(null);
- activeRule.setNoteUpdatedAt(null);
- activeRuleDao.update(activeRule);
- session.commit();
-
- reindexActiveRule(activeRule, session);
- } finally {
- MyBatis.closeQuietly(session);
- }
- }
-
- public void updateRuleNote(RuleDto rule, String note, UserSession userSession) {
- checkPermission(userSession);
- Date now = new Date(system.now());
-
- SqlSession session = myBatis.openSession();
- try {
- if (rule.getNoteData() == null) {
- rule.setNoteCreatedAt(now);
- rule.setNoteUserLogin(getLoggedLogin(userSession));
- }
- rule.setNoteUpdatedAt(now);
- rule.setNoteData(note);
- ruleDao.update(rule);
- session.commit();
-
- reindexRule(rule, session);
- } finally {
- MyBatis.closeQuietly(session);
- }
- }
-
- public void deleteRuleNote(RuleDto rule, UserSession userSession) {
- checkPermission(userSession);
-
- SqlSession session = myBatis.openSession();
- try {
- rule.setNoteData(null);
- rule.setNoteUserLogin(null);
- rule.setNoteCreatedAt(null);
- rule.setNoteUpdatedAt(null);
- ruleDao.update(rule);
- session.commit();
-
- reindexRule(rule, session);
- } finally {
- MyBatis.closeQuietly(session);
- }
- }
-
- public RuleDto createRule(RuleDto templateRule, String name, String severity, String description, Map<String, String> paramsByKey,
- UserSession userSession) {
- checkPermission(userSession);
- SqlSession session = myBatis.openSession();
- try {
- RuleDto rule = new RuleDto()
- .setParentId(templateRule.getId())
- .setName(name)
- .setDescription(description)
- .setSeverity(Severity.ordinal(severity))
- .setRepositoryKey(templateRule.getRepositoryKey())
- .setConfigKey(templateRule.getConfigKey())
- .setRuleKey(templateRule.getRuleKey() + "_" + system.now())
- .setCardinality(Cardinality.SINGLE)
- .setStatus(Rule.STATUS_READY)
- .setLanguage(templateRule.getLanguage())
- .setCreatedAt(new Date(system.now()))
- .setUpdatedAt(new Date(system.now()));
- ruleDao.insert(rule, session);
-
- List<RuleParamDto> templateRuleParams = ruleDao.selectParameters(templateRule.getId(), session);
- List<RuleParamDto> ruleParams = newArrayList();
- for (RuleParamDto templateRuleParam : templateRuleParams) {
- String key = templateRuleParam.getName();
- String value = paramsByKey.get(key);
-
- RuleParamDto param = new RuleParamDto()
- .setRuleId(rule.getId())
- .setName(key)
- .setDescription(templateRuleParam.getDescription())
- .setType(templateRuleParam.getType())
- .setDefaultValue(Strings.emptyToNull(value));
- ruleDao.insert(param, session);
- ruleParams.add(param);
- }
- session.commit();
- reindexRule(rule, ruleParams);
- return rule;
- } finally {
- MyBatis.closeQuietly(session);
- }
- }
-
- public void updateRule(RuleDto rule, String name, String severity, String description, Map<String, String> paramsByKey,
- UserSession userSession) {
- checkPermission(userSession);
- SqlSession session = myBatis.openSession();
- try {
- rule.setName(name)
- .setDescription(description)
- .setSeverity(Severity.ordinal(severity))
- .setUpdatedAt(new Date(system.now()));
- ruleDao.update(rule, session);
-
- List<RuleParamDto> ruleParams = ruleDao.selectParameters(rule.getId(), session);
- for (RuleParamDto ruleParam : ruleParams) {
- String value = paramsByKey.get(ruleParam.getName());
- ruleParam.setDefaultValue(Strings.emptyToNull(value));
- ruleDao.update(ruleParam, session);
- }
- session.commit();
- reindexRule(rule, ruleParams);
- } finally {
- MyBatis.closeQuietly(session);
- }
- }
-
- public void deleteRule(RuleDto rule, UserSession userSession) {
- checkPermission(userSession);
- SqlSession session = myBatis.openSession();
- try {
- // Set status REMOVED on rule
- rule.setStatus(Rule.STATUS_REMOVED)
- .setUpdatedAt(new Date(system.now()));
- ruleDao.update(rule, session);
- session.commit();
- reindexRule(rule, session);
-
- // Delete all active rules and active rule params linked to the rule
- List<ActiveRuleDto> activeRules = activeRuleDao.selectByRuleId(rule.getId());
- for (ActiveRuleDto activeRule : activeRules) {
- activeRuleDao.deleteParameters(activeRule.getId(), session);
- }
- activeRuleDao.deleteFromRule(rule.getId(), session);
- session.commit();
- ruleRegistry.deleteActiveRules(newArrayList(Iterables.transform(activeRules, new Function<ActiveRuleDto, Integer>() {
- @Override
- public Integer apply(ActiveRuleDto input) {
- return input.getId();
- }
- })));
- } finally {
- MyBatis.closeQuietly(session);
- }
- }
-
- private void reindexInheritanceResult(RuleInheritanceActions actions, SqlSession session) {
- ruleRegistry.deleteActiveRules(actions.idsToDelete());
- List<ActiveRuleDto> activeRules = activeRuleDao.selectByIds(actions.idsToIndex(), session);
- Multimap<Integer, ActiveRuleParamDto> paramsByActiveRule = ArrayListMultimap.create();
- for (ActiveRuleParamDto param : activeRuleDao.selectParamsByActiveRuleIds(actions.idsToIndex(), session)) {
- paramsByActiveRule.put(param.getActiveRuleId(), param);
- }
- ruleRegistry.bulkIndexActiveRules(activeRules, paramsByActiveRule);
- }
-
- private void reindexActiveRule(ActiveRuleDto activeRuleDto, SqlSession session) {
- ruleRegistry.save(activeRuleDto, activeRuleDao.selectParamsByActiveRuleId(activeRuleDto.getId(), session));
- }
-
- private void reindexRule(RuleDto rule, SqlSession session) {
- ruleRegistry.save(rule, ruleDao.selectParameters(rule.getId(), session));
- }
-
- private void reindexRule(RuleDto rule, List<RuleParamDto> ruleParams) {
- ruleRegistry.save(rule, ruleParams);
- }
-
private List<RulesProfile> readProfilesFromXml(NewProfileResult result, Map<String, String> xmlProfilesByPlugin) {
List<RulesProfile> profiles = newArrayList();
ValidationMessages messages = ValidationMessages.create();
userSession.checkGlobalPermission(GlobalPermissions.QUALITY_PROFILE_ADMIN);
}
- private String getLoggedName(UserSession userSession) {
- String name = userSession.name();
- if (Strings.isNullOrEmpty(name)) {
- throw new BadRequestException("User name can't be null");
- }
- return name;
- }
-
- private String getLoggedLogin(UserSession userSession) {
- String login = userSession.login();
- if (Strings.isNullOrEmpty(login)) {
- throw new BadRequestException("User login can't be null");
- }
- return login;
- }
-
- private void checkSeverity(String severity) {
- if (!Severity.ALL.contains(severity)) {
- throw new BadRequestException("The severity is not valid");
- }
- }
-
- private RuleParamDto findRuleParamNotNull(Integer ruleId, String key, SqlSession session) {
- RuleParamDto ruleParam = ruleDao.selectParamByRuleAndKey(ruleId, key, session);
- if (ruleParam == null) {
- throw new IllegalArgumentException("No rule param found");
- }
- return ruleParam;
- }
-
- private void validateParam(String type, String value) {
- if (type.equals(PropertyType.INTEGER.name()) && !NumberUtils.isDigits(value)) {
- throw new BadRequestException(String.format("Value '%s' must be an integer.", value));
- }
- }
-
}
--- /dev/null
+/*
+ * SonarQube, open source software quality management tool.
+ * Copyright (C) 2008-2013 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.server.qualityprofile;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Strings;
+import com.google.common.collect.Iterables;
+import org.apache.ibatis.session.SqlSession;
+import org.sonar.api.ServerComponent;
+import org.sonar.api.rule.Severity;
+import org.sonar.api.rules.Rule;
+import org.sonar.api.utils.System2;
+import org.sonar.check.Cardinality;
+import org.sonar.core.permission.GlobalPermissions;
+import org.sonar.core.persistence.MyBatis;
+import org.sonar.core.qualityprofile.db.ActiveRuleDao;
+import org.sonar.core.qualityprofile.db.ActiveRuleDto;
+import org.sonar.core.rule.RuleDao;
+import org.sonar.core.rule.RuleDto;
+import org.sonar.core.rule.RuleParamDto;
+import org.sonar.server.exceptions.BadRequestException;
+import org.sonar.server.rule.RuleRegistry;
+import org.sonar.server.user.UserSession;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+import static com.google.common.collect.Lists.newArrayList;
+
+public class QProfileRuleOperations implements ServerComponent {
+
+ private final MyBatis myBatis;
+ private final ActiveRuleDao activeRuleDao;
+ private final RuleDao ruleDao;
+ private final RuleRegistry ruleRegistry;
+
+ private final System2 system;
+
+ public QProfileRuleOperations(MyBatis myBatis, ActiveRuleDao activeRuleDao, RuleDao ruleDao, RuleRegistry ruleRegistry) {
+ this(myBatis, activeRuleDao, ruleDao, ruleRegistry, System2.INSTANCE);
+ }
+
+ @VisibleForTesting
+ QProfileRuleOperations(MyBatis myBatis, ActiveRuleDao activeRuleDao, RuleDao ruleDao, RuleRegistry ruleRegistry, System2 system) {
+ this.myBatis = myBatis;
+ this.activeRuleDao = activeRuleDao;
+ this.ruleDao = ruleDao;
+ this.ruleRegistry = ruleRegistry;
+ this.system = system;
+ }
+
+ public void updateRuleNote(RuleDto rule, String note, UserSession userSession) {
+ checkPermission(userSession);
+ Date now = new Date(system.now());
+
+ SqlSession session = myBatis.openSession();
+ try {
+ if (rule.getNoteData() == null) {
+ rule.setNoteCreatedAt(now);
+ rule.setNoteUserLogin(getLoggedLogin(userSession));
+ }
+ rule.setNoteUpdatedAt(now);
+ rule.setNoteData(note);
+ ruleDao.update(rule);
+ session.commit();
+
+ reindexRule(rule, session);
+ } finally {
+ MyBatis.closeQuietly(session);
+ }
+ }
+
+ public void deleteRuleNote(RuleDto rule, UserSession userSession) {
+ checkPermission(userSession);
+
+ SqlSession session = myBatis.openSession();
+ try {
+ rule.setNoteData(null);
+ rule.setNoteUserLogin(null);
+ rule.setNoteCreatedAt(null);
+ rule.setNoteUpdatedAt(null);
+ ruleDao.update(rule);
+ session.commit();
+
+ reindexRule(rule, session);
+ } finally {
+ MyBatis.closeQuietly(session);
+ }
+ }
+
+ public RuleDto createRule(RuleDto templateRule, String name, String severity, String description, Map<String, String> paramsByKey,
+ UserSession userSession) {
+ checkPermission(userSession);
+ SqlSession session = myBatis.openSession();
+ try {
+ RuleDto rule = new RuleDto()
+ .setParentId(templateRule.getId())
+ .setName(name)
+ .setDescription(description)
+ .setSeverity(Severity.ordinal(severity))
+ .setRepositoryKey(templateRule.getRepositoryKey())
+ .setConfigKey(templateRule.getConfigKey())
+ .setRuleKey(templateRule.getRuleKey() + "_" + system.now())
+ .setCardinality(Cardinality.SINGLE)
+ .setStatus(Rule.STATUS_READY)
+ .setLanguage(templateRule.getLanguage())
+ .setCreatedAt(new Date(system.now()))
+ .setUpdatedAt(new Date(system.now()));
+ ruleDao.insert(rule, session);
+
+ List<RuleParamDto> templateRuleParams = ruleDao.selectParameters(templateRule.getId(), session);
+ List<RuleParamDto> ruleParams = newArrayList();
+ for (RuleParamDto templateRuleParam : templateRuleParams) {
+ String key = templateRuleParam.getName();
+ String value = paramsByKey.get(key);
+
+ RuleParamDto param = new RuleParamDto()
+ .setRuleId(rule.getId())
+ .setName(key)
+ .setDescription(templateRuleParam.getDescription())
+ .setType(templateRuleParam.getType())
+ .setDefaultValue(Strings.emptyToNull(value));
+ ruleDao.insert(param, session);
+ ruleParams.add(param);
+ }
+ session.commit();
+ reindexRule(rule, ruleParams);
+ return rule;
+ } finally {
+ MyBatis.closeQuietly(session);
+ }
+ }
+
+ public void updateRule(RuleDto rule, String name, String severity, String description, Map<String, String> paramsByKey,
+ UserSession userSession) {
+ checkPermission(userSession);
+ SqlSession session = myBatis.openSession();
+ try {
+ rule.setName(name)
+ .setDescription(description)
+ .setSeverity(Severity.ordinal(severity))
+ .setUpdatedAt(new Date(system.now()));
+ ruleDao.update(rule, session);
+
+ List<RuleParamDto> ruleParams = ruleDao.selectParameters(rule.getId(), session);
+ for (RuleParamDto ruleParam : ruleParams) {
+ String value = paramsByKey.get(ruleParam.getName());
+ ruleParam.setDefaultValue(Strings.emptyToNull(value));
+ ruleDao.update(ruleParam, session);
+ }
+ session.commit();
+ reindexRule(rule, ruleParams);
+ } finally {
+ MyBatis.closeQuietly(session);
+ }
+ }
+
+ public void deleteRule(RuleDto rule, UserSession userSession) {
+ checkPermission(userSession);
+ SqlSession session = myBatis.openSession();
+ try {
+ // Set status REMOVED on rule
+ rule.setStatus(Rule.STATUS_REMOVED)
+ .setUpdatedAt(new Date(system.now()));
+ ruleDao.update(rule, session);
+ session.commit();
+ reindexRule(rule, session);
+
+ // Delete all active rules and active rule params linked to the rule
+ List<ActiveRuleDto> activeRules = activeRuleDao.selectByRuleId(rule.getId());
+ for (ActiveRuleDto activeRule : activeRules) {
+ activeRuleDao.deleteParameters(activeRule.getId(), session);
+ }
+ activeRuleDao.deleteFromRule(rule.getId(), session);
+ session.commit();
+ ruleRegistry.deleteActiveRules(newArrayList(Iterables.transform(activeRules, new Function<ActiveRuleDto, Integer>() {
+ @Override
+ public Integer apply(ActiveRuleDto input) {
+ return input.getId();
+ }
+ })));
+ } finally {
+ MyBatis.closeQuietly(session);
+ }
+ }
+
+ private void reindexRule(RuleDto rule, SqlSession session) {
+ ruleRegistry.save(rule, ruleDao.selectParameters(rule.getId(), session));
+ }
+
+ private void reindexRule(RuleDto rule, List<RuleParamDto> ruleParams) {
+ ruleRegistry.save(rule, ruleParams);
+ }
+
+ private void checkPermission(UserSession userSession) {
+ userSession.checkLoggedIn();
+ userSession.checkGlobalPermission(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ }
+
+ private String getLoggedLogin(UserSession userSession) {
+ String login = userSession.login();
+ if (Strings.isNullOrEmpty(login)) {
+ throw new BadRequestException("User login can't be null");
+ }
+ return login;
+ }
+
+}
private final QProfileSearch search;
private final QProfileOperations operations;
+ private final QProfileActiveRuleOperations activeRuleOperations;
+ private final QProfileRuleOperations ruleOperations;
private final ProfileRules rules;
public QProfiles(QualityProfileDao qualityProfileDao, ActiveRuleDao activeRuleDao, RuleDao ruleDao, ResourceDao resourceDao,
- QProfileProjectService projectService, QProfileSearch search, QProfileOperations operations, ProfileRules rules) {
+ QProfileProjectService projectService, QProfileSearch search,
+ QProfileOperations operations, QProfileActiveRuleOperations activeRuleOperations, QProfileRuleOperations ruleOperations, ProfileRules rules) {
this.qualityProfileDao = qualityProfileDao;
this.activeRuleDao = activeRuleDao;
this.ruleDao = ruleDao;
this.projectService = projectService;
this.search = search;
this.operations = operations;
+ this.activeRuleOperations = activeRuleOperations;
+ this.ruleOperations = ruleOperations;
this.rules = rules;
}
// ACTIVE RULES
// bulk activate all
// bulk deactivate all
- // revert modification on active rule with inheritance
+ // revert modification on active rule with inheritance -->
// active rule parameter validation (only Integer types are checked)
RuleDto rule = findRuleNotNull(ruleId);
ActiveRuleDto activeRule = findActiveRule(qualityProfile, rule);
if (activeRule == null) {
- activeRule = operations.createActiveRule(qualityProfile, rule, severity, UserSession.get());
+ activeRule = activeRuleOperations.createActiveRule(qualityProfile, rule, severity, UserSession.get());
} else {
- operations.updateSeverity(activeRule, severity, UserSession.get());
+ activeRuleOperations.updateSeverity(activeRule, severity, UserSession.get());
}
return activeRuleChanged(qualityProfile, activeRule);
}
QualityProfileDto qualityProfile = findNotNull(profileId);
RuleDto rule = findRuleNotNull(ruleId);
ActiveRuleDto activeRule = findActiveRuleNotNull(qualityProfile, rule);
- operations.deactivateRule(activeRule, UserSession.get());
- return activeRuleChanged(qualityProfile, activeRule);
+ activeRuleOperations.deactivateRule(activeRule, UserSession.get());
+ return activeRuleChanged(qualityProfile, rule);
}
/**
ActiveRuleDto activeRule = findActiveRuleNotNull(activeRuleId);
UserSession userSession = UserSession.get();
if (activeRuleParam == null && sanitizedValue != null) {
- operations.createActiveRuleParam(activeRule, key, value, userSession);
+ activeRuleOperations.createActiveRuleParam(activeRule, key, value, userSession);
} else if (activeRuleParam != null && sanitizedValue == null) {
- operations.deleteActiveRuleParam(activeRule, activeRuleParam, userSession);
+ activeRuleOperations.deleteActiveRuleParam(activeRule, activeRuleParam, userSession);
} else if (activeRuleParam != null) {
- operations.updateActiveRuleParam(activeRule, activeRuleParam, value, userSession);
+ activeRuleOperations.updateActiveRuleParam(activeRule, activeRuleParam, value, userSession);
} else {
// No active rule param and no value -> do nothing
}
ActiveRuleDto activeRule = findActiveRuleNotNull(activeRuleId);
String sanitizedNote = Strings.emptyToNull(note);
if (sanitizedNote != null) {
- operations.updateActiveRuleNote(activeRule, note, UserSession.get());
+ activeRuleOperations.updateActiveRuleNote(activeRule, note, UserSession.get());
} else {
// Empty note -> do nothing
}
public QProfileRule deleteActiveRuleNote(int activeRuleId) {
ActiveRuleDto activeRule = findActiveRuleNotNull(activeRuleId);
- operations.deleteActiveRuleNote(activeRule, UserSession.get());
+ activeRuleOperations.deleteActiveRuleNote(activeRule, UserSession.get());
return rules.getFromActiveRuleId(activeRule.getId());
}
RuleDto rule = findRuleNotNull(ruleId);
String sanitizedNote = Strings.emptyToNull(note);
if (sanitizedNote != null) {
- operations.updateRuleNote(rule, note, UserSession.get());
+ ruleOperations.updateRuleNote(rule, note, UserSession.get());
} else {
- operations.deleteRuleNote(rule, UserSession.get());
+ ruleOperations.deleteRuleNote(rule, UserSession.get());
}
ActiveRuleDto activeRule = findActiveRuleNotNull(activeRuleId);
return rules.getFromActiveRuleId(activeRule.getId());
public QProfileRule createRule(int ruleId, @Nullable String name, @Nullable String severity, @Nullable String description, Map<String, String> paramsByKey) {
RuleDto rule = findRuleNotNull(ruleId);
validateRule(null, name, severity, description);
- RuleDto newRule = operations.createRule(rule, name, severity, description, paramsByKey, UserSession.get());
+ RuleDto newRule = ruleOperations.createRule(rule, name, severity, description, paramsByKey, UserSession.get());
return rules.getFromRuleId(newRule.getId());
}
public QProfileRule updateRule(int ruleId, @Nullable String name, @Nullable String severity, @Nullable String description, Map<String, String> paramsByKey) {
RuleDto rule = findRuleNotNull(ruleId);
- if (rule.getParentId() == null) {
- throw new NotFoundException("Unknown rule");
- }
+ validateRuleParent(rule);
validateRule(ruleId, name, severity, description);
- operations.updateRule(rule, name, severity, description, paramsByKey, UserSession.get());
+ ruleOperations.updateRule(rule, name, severity, description, paramsByKey, UserSession.get());
return rules.getFromRuleId(ruleId);
}
public void deleteRule(int ruleId) {
RuleDto rule = findRuleNotNull(ruleId);
- if (rule.getParentId() == null) {
- throw new NotFoundException("Unknown rule");
- }
- operations.deleteRule(rule, UserSession.get());
+ validateRuleParent(rule);
+ ruleOperations.deleteRule(rule, UserSession.get());
}
public int countActiveRules(QProfileRule rule){
return rule;
}
+ private void validateRuleParent(RuleDto rule){
+ if (rule.getParentId() == null) {
+ throw new NotFoundException("Unknown rule");
+ }
+ }
+
//
// Active Rule validation
//
return new ActiveRuleChanged(QProfile.from(qualityProfile), rules.getFromActiveRuleId(activeRule.getId()));
}
+ private ActiveRuleChanged activeRuleChanged(QualityProfileDto qualityProfile, RuleDto rule) {
+ return new ActiveRuleChanged(QProfile.from(qualityProfile), rules.getFromRuleId(rule.getId()));
+ }
+
}
--- /dev/null
+/*
+ * SonarQube, open source software quality management tool.
+ * Copyright (C) 2008-2013 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.server.qualityprofile;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Multimap;
+import org.apache.ibatis.session.SqlSession;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.mockito.stubbing.Answer;
+import org.sonar.api.PropertyType;
+import org.sonar.api.rule.Severity;
+import org.sonar.api.rules.Rule;
+import org.sonar.api.rules.RulePriority;
+import org.sonar.api.utils.DateUtils;
+import org.sonar.api.utils.System2;
+import org.sonar.core.permission.GlobalPermissions;
+import org.sonar.core.persistence.MyBatis;
+import org.sonar.core.preview.PreviewCache;
+import org.sonar.core.qualityprofile.db.ActiveRuleDao;
+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.RuleDao;
+import org.sonar.core.rule.RuleDto;
+import org.sonar.core.rule.RuleParamDto;
+import org.sonar.server.configuration.ProfilesManager;
+import org.sonar.server.exceptions.BadRequestException;
+import org.sonar.server.exceptions.ForbiddenException;
+import org.sonar.server.rule.RuleRegistry;
+import org.sonar.server.user.MockUserSession;
+import org.sonar.server.user.UserSession;
+
+import java.util.Date;
+import java.util.List;
+
+import static com.google.common.collect.Lists.newArrayList;
+import static org.fest.assertions.Assertions.assertThat;
+import static org.fest.assertions.Fail.fail;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Matchers.anyList;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Matchers.isA;
+import static org.mockito.Mockito.*;
+
+@RunWith(MockitoJUnitRunner.class)
+public class QProfileActiveRuleOperationsTest {
+
+ @Mock
+ MyBatis myBatis;
+
+ @Mock
+ SqlSession session;
+
+ @Mock
+ ActiveRuleDao activeRuleDao;
+
+ @Mock
+ RuleDao ruleDao;
+
+ @Mock
+ PreviewCache dryRunCache;
+
+ @Mock
+ RuleRegistry ruleRegistry;
+
+ @Mock
+ ProfilesManager profilesManager;
+
+ @Mock
+ System2 system;
+
+ Integer currentId = 1;
+
+ UserSession authorizedUserSession = MockUserSession.create().setLogin("nicolas").setName("Nicolas").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ UserSession unauthorizedUserSession = MockUserSession.create().setLogin("nicolas").setName("Nicolas");
+
+ QProfileActiveRuleOperations operations;
+
+ @Before
+ public void setUp() throws Exception {
+ when(myBatis.openSession()).thenReturn(session);
+
+ // Associate an id when inserting an object to simulate the db id generator
+ doAnswer(new Answer() {
+ public Object answer(InvocationOnMock invocation) {
+ Object[] args = invocation.getArguments();
+ ActiveRuleDto dto = (ActiveRuleDto) args[0];
+ dto.setId(currentId++);
+ return null;
+ }
+ }).when(activeRuleDao).insert(any(ActiveRuleDto.class), any(SqlSession.class));
+
+ operations = new QProfileActiveRuleOperations(myBatis, activeRuleDao, ruleDao, dryRunCache, ruleRegistry, profilesManager, system);
+ }
+
+ @Test
+ public void fail_to_activate_rule_without_profile_admin_permission() throws Exception {
+ QualityProfileDto qualityProfile = new QualityProfileDto().setId(1).setName("My profile").setLanguage("java");
+ RuleDto rule = new RuleDto().setId(10).setRepositoryKey("squid").setRuleKey("AvoidCycle");
+
+ try {
+ operations.createActiveRule(qualityProfile, rule, Severity.CRITICAL, unauthorizedUserSession);
+ fail();
+ } catch (Exception e) {
+ assertThat(e).isInstanceOf(ForbiddenException.class);
+ }
+ verifyNoMoreInteractions(activeRuleDao);
+ verify(session, never()).commit();
+ }
+
+ @Test
+ public void activate_rule() throws Exception {
+ QualityProfileDto qualityProfile = new QualityProfileDto().setId(1).setName("My profile").setLanguage("java");
+ RuleDto rule = new RuleDto().setId(10).setRepositoryKey("squid").setRuleKey("AvoidCycle");
+ when(ruleDao.selectParameters(eq(10), eq(session))).thenReturn(newArrayList(new RuleParamDto().setId(20).setName("max").setDefaultValue("10")));
+ final int idActiveRuleToUpdate = 42;
+ final int idActiveRuleToDelete = 24;
+ RuleInheritanceActions inheritanceActions = new RuleInheritanceActions()
+ .addToIndex(idActiveRuleToUpdate)
+ .addToDelete(idActiveRuleToDelete);
+ when(profilesManager.activated(eq(1), anyInt(), eq("Nicolas"))).thenReturn(inheritanceActions);
+ when(activeRuleDao.selectByIds(anyList(), isA(SqlSession.class))).thenReturn(ImmutableList.<ActiveRuleDto>of(mock(ActiveRuleDto.class)));
+ when(activeRuleDao.selectParamsByActiveRuleIds(anyList(), isA(SqlSession.class))).thenReturn(ImmutableList.<ActiveRuleParamDto>of(mock(ActiveRuleParamDto.class)));
+
+ ActiveRuleDto result = operations.createActiveRule(qualityProfile, rule, Severity.CRITICAL, authorizedUserSession);
+ assertThat(result).isNotNull();
+
+ ArgumentCaptor<ActiveRuleDto> activeRuleArgument = ArgumentCaptor.forClass(ActiveRuleDto.class);
+ verify(activeRuleDao).insert(activeRuleArgument.capture(), eq(session));
+ assertThat(activeRuleArgument.getValue().getRulId()).isEqualTo(10);
+ assertThat(activeRuleArgument.getValue().getSeverity()).isEqualTo(3);
+
+ ArgumentCaptor<ActiveRuleParamDto> activeRuleParamArgument = ArgumentCaptor.forClass(ActiveRuleParamDto.class);
+ verify(activeRuleDao).insert(activeRuleParamArgument.capture(), eq(session));
+ assertThat(activeRuleParamArgument.getValue().getKey()).isEqualTo("max");
+ assertThat(activeRuleParamArgument.getValue().getValue()).isEqualTo("10");
+
+ verify(session).commit();
+ verify(profilesManager).activated(eq(1), anyInt(), eq("Nicolas"));
+ verify(ruleRegistry).bulkIndexActiveRules(anyList(), isA(Multimap.class));
+ }
+
+ @Test
+ public void update_severity() throws Exception {
+ Rule rule = Rule.create().setRepositoryKey("squid").setKey("AvoidCycle");
+ rule.setId(10);
+ ActiveRuleDto activeRule = new ActiveRuleDto().setId(5).setProfileId(1).setRuleId(10).setSeverity(1);
+ when(profilesManager.ruleSeverityChanged(eq(1), eq(5), eq(RulePriority.MINOR), eq(RulePriority.MAJOR), eq("Nicolas"))).thenReturn(new RuleInheritanceActions());
+
+ operations.updateSeverity(activeRule, Severity.MAJOR, authorizedUserSession);
+
+ verify(activeRuleDao).update(eq(activeRule), eq(session));
+ verify(session).commit();
+ verify(profilesManager).ruleSeverityChanged(eq(1), eq(5), eq(RulePriority.MINOR), eq(RulePriority.MAJOR), eq("Nicolas"));
+ verify(ruleRegistry).bulkIndexActiveRules(anyList(), isA(Multimap.class));
+ }
+
+ @Test
+ public void fail_to_update_severity_on_invalid_severity() throws Exception {
+ Rule rule = Rule.create().setRepositoryKey("squid").setKey("AvoidCycle");
+ rule.setId(10);
+ ActiveRuleDto activeRule = new ActiveRuleDto().setId(5).setProfileId(1).setRuleId(10).setSeverity(1);
+
+ try {
+ operations.updateSeverity(activeRule, "Unknown", authorizedUserSession);
+ fail();
+ } catch (Exception e) {
+ assertThat(e).isInstanceOf(BadRequestException.class);
+ }
+ verify(activeRuleDao, never()).update(eq(activeRule), eq(session));
+ verifyZeroInteractions(profilesManager);
+ }
+
+ @Test
+ public void deactivate_rule() throws Exception {
+ ActiveRuleDto activeRule = new ActiveRuleDto().setId(5).setProfileId(1).setRuleId(10).setSeverity(1);
+ when(activeRuleDao.selectByProfileAndRule(1, 10)).thenReturn(activeRule);
+ when(profilesManager.deactivated(eq(1), anyInt(), eq("Nicolas"))).thenReturn(new RuleInheritanceActions());
+
+ operations.deactivateRule(activeRule, authorizedUserSession);
+
+ verify(activeRuleDao).delete(eq(5), eq(session));
+ verify(activeRuleDao).deleteParameters(eq(5), eq(session));
+ verify(session).commit();
+ verify(profilesManager).deactivated(eq(1), anyInt(), eq("Nicolas"));
+ verify(ruleRegistry).bulkIndexActiveRules(anyList(), isA(Multimap.class));
+ }
+
+ @Test
+ public void update_active_rule_param() throws Exception {
+ ActiveRuleDto activeRule = new ActiveRuleDto().setId(5).setProfileId(1).setRuleId(10).setSeverity(1);
+ ActiveRuleParamDto activeRuleParam = new ActiveRuleParamDto().setId(100).setActiveRuleId(5).setKey("max").setValue("20");
+
+ RuleParamDto ruleParam = new RuleParamDto().setRuleId(10).setName("max").setDefaultValue("20").setType(PropertyType.INTEGER.name());
+ when(ruleDao.selectParamByRuleAndKey(10, "max", session)).thenReturn(ruleParam);
+
+ when(profilesManager.ruleParamChanged(eq(1), eq(5), eq("max"), eq("20"), eq("30"), eq("Nicolas"))).thenReturn(new RuleInheritanceActions());
+
+ operations.updateActiveRuleParam(activeRule, activeRuleParam, "30", authorizedUserSession);
+
+ ArgumentCaptor<ActiveRuleParamDto> argumentCaptor = ArgumentCaptor.forClass(ActiveRuleParamDto.class);
+ verify(activeRuleDao).update(argumentCaptor.capture(), eq(session));
+ assertThat(argumentCaptor.getValue().getId()).isEqualTo(100);
+ assertThat(argumentCaptor.getValue().getValue()).isEqualTo("30");
+
+ verify(session).commit();
+ verify(profilesManager).ruleParamChanged(eq(1), eq(5), eq("max"), eq("20"), eq("30"), eq("Nicolas"));
+ verify(ruleRegistry).bulkIndexActiveRules(anyList(), isA(Multimap.class));
+ }
+
+ @Test
+ public void remove_active_rule_param() throws Exception {
+ ActiveRuleDto activeRule = new ActiveRuleDto().setId(5).setProfileId(1).setRuleId(10).setSeverity(1);
+ ActiveRuleParamDto activeRuleParam = new ActiveRuleParamDto().setId(100).setActiveRuleId(5).setKey("max").setValue("20");
+ when(profilesManager.ruleParamChanged(eq(1), eq(5), eq("max"), eq("20"), eq((String) null), eq("Nicolas"))).thenReturn(new RuleInheritanceActions());
+
+ operations.deleteActiveRuleParam(activeRule, activeRuleParam, authorizedUserSession);
+
+ verify(session).commit();
+ verify(activeRuleDao).deleteParameter(100, session);
+ verify(profilesManager).ruleParamChanged(eq(1), eq(5), eq("max"), eq("20"), eq((String) null), eq("Nicolas"));
+ verify(ruleRegistry).bulkIndexActiveRules(anyList(), isA(Multimap.class));
+ }
+
+ @Test
+ public void create_active_rule_param() throws Exception {
+ ActiveRuleDto activeRule = new ActiveRuleDto().setId(5).setProfileId(1).setRuleId(10).setSeverity(1);
+ RuleParamDto ruleParam = new RuleParamDto().setRuleId(10).setName("max").setDefaultValue("20").setType(PropertyType.INTEGER.name());
+ when(ruleDao.selectParamByRuleAndKey(10, "max", session)).thenReturn(ruleParam);
+ when(profilesManager.ruleParamChanged(eq(1), eq(5), eq("max"), eq((String) null), eq("30"), eq("Nicolas"))).thenReturn(new RuleInheritanceActions());
+
+ operations.createActiveRuleParam(activeRule, "max", "30", authorizedUserSession);
+
+ ArgumentCaptor<ActiveRuleParamDto> argumentCaptor = ArgumentCaptor.forClass(ActiveRuleParamDto.class);
+ verify(activeRuleDao).insert(argumentCaptor.capture(), eq(session));
+ assertThat(argumentCaptor.getValue().getKey()).isEqualTo("max");
+ assertThat(argumentCaptor.getValue().getValue()).isEqualTo("30");
+ assertThat(argumentCaptor.getValue().getActiveRuleId()).isEqualTo(5);
+
+ verify(session).commit();
+ verify(profilesManager).ruleParamChanged(eq(1), eq(5), eq("max"), eq((String) null), eq("30"), eq("Nicolas"));
+ verify(ruleRegistry).bulkIndexActiveRules(anyList(), isA(Multimap.class));
+ }
+
+ @Test
+ public void fail_to_create_active_rule_if_no_rule_param() throws Exception {
+ ActiveRuleDto activeRule = new ActiveRuleDto().setId(5).setProfileId(1).setRuleId(10).setSeverity(1);
+ when(ruleDao.selectParamByRuleAndKey(10, "max", session)).thenReturn(null);
+ try {
+ operations.createActiveRuleParam(activeRule, "max", "30", authorizedUserSession);
+ fail();
+ } catch (Exception e) {
+ assertThat(e).isInstanceOf(IllegalArgumentException.class);
+ }
+ verify(activeRuleDao, never()).insert(any(ActiveRuleParamDto.class), eq(session));
+ verifyZeroInteractions(profilesManager);
+ }
+
+ @Test
+ public void fail_to_create_active_rule_if_type_is_invalid() throws Exception {
+ RuleParamDto ruleParam = new RuleParamDto().setRuleId(10).setName("max").setDefaultValue("20").setType(PropertyType.INTEGER.name());
+ when(ruleDao.selectParamByRuleAndKey(10, "max", session)).thenReturn(ruleParam);
+
+ ActiveRuleDto activeRule = new ActiveRuleDto().setId(5).setProfileId(1).setRuleId(10).setSeverity(1);
+ try {
+ operations.createActiveRuleParam(activeRule, "max", "invalid integer", authorizedUserSession);
+ fail();
+ } catch (Exception e) {
+ assertThat(e).isInstanceOf(BadRequestException.class);
+ }
+ verify(activeRuleDao, never()).insert(any(ActiveRuleParamDto.class), eq(session));
+ verifyZeroInteractions(profilesManager);
+ }
+
+ @Test
+ public void update_active_rule_note_when_no_existing_note() throws Exception {
+ ActiveRuleDto activeRule = new ActiveRuleDto().setId(5).setProfileId(1).setRuleId(10).setSeverity(1).setNoteCreatedAt(null).setNoteData(null);
+
+ List<ActiveRuleParamDto> activeRuleParams = newArrayList(new ActiveRuleParamDto());
+ when(activeRuleDao.selectParamsByActiveRuleId(eq(5), eq(session))).thenReturn(activeRuleParams);
+
+ long now = System.currentTimeMillis();
+ doReturn(now).when(system).now();
+
+ operations.updateActiveRuleNote(activeRule, "My note", authorizedUserSession);
+
+ ArgumentCaptor<ActiveRuleDto> argumentCaptor = ArgumentCaptor.forClass(ActiveRuleDto.class);
+ verify(activeRuleDao).update(argumentCaptor.capture(), eq(session));
+ assertThat(argumentCaptor.getValue().getNoteData()).isEqualTo("My note");
+ assertThat(argumentCaptor.getValue().getNoteUserLogin()).isEqualTo("nicolas");
+ assertThat(argumentCaptor.getValue().getNoteCreatedAt().getTime()).isEqualTo(now);
+ assertThat(argumentCaptor.getValue().getNoteUpdatedAt().getTime()).isEqualTo(now);
+
+ verify(session).commit();
+ verify(ruleRegistry).save(eq(activeRule), eq(activeRuleParams));
+ }
+
+ @Test
+ public void update_active_rule_note_when_already_note() throws Exception {
+ Date createdAt = DateUtils.parseDate("2013-12-20");
+ ActiveRuleDto activeRule = new ActiveRuleDto().setId(5).setProfileId(1).setRuleId(10).setSeverity(1)
+ .setNoteCreatedAt(createdAt).setNoteData("My previous note").setNoteUserLogin("nicolas");
+
+ List<ActiveRuleParamDto> activeRuleParams = newArrayList(new ActiveRuleParamDto());
+ when(activeRuleDao.selectParamsByActiveRuleId(eq(5), eq(session))).thenReturn(activeRuleParams);
+
+ long now = System.currentTimeMillis();
+ doReturn(now).when(system).now();
+
+ operations.updateActiveRuleNote(activeRule, "My new note", MockUserSession.create().setLogin("guy").setName("Guy").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN));
+
+ ArgumentCaptor<ActiveRuleDto> argumentCaptor = ArgumentCaptor.forClass(ActiveRuleDto.class);
+ verify(activeRuleDao).update(argumentCaptor.capture(), eq(session));
+ assertThat(argumentCaptor.getValue().getNoteData()).isEqualTo("My new note");
+ assertThat(argumentCaptor.getValue().getNoteUserLogin()).isEqualTo("nicolas");
+ assertThat(argumentCaptor.getValue().getNoteCreatedAt()).isEqualTo(createdAt);
+ assertThat(argumentCaptor.getValue().getNoteUpdatedAt().getTime()).isEqualTo(now);
+
+ verify(session).commit();
+ verify(ruleRegistry).save(eq(activeRule), eq(activeRuleParams));
+ }
+
+ @Test
+ public void delete_active_rule_note() throws Exception {
+ Date createdAt = DateUtils.parseDate("2013-12-20");
+ ActiveRuleDto activeRule = new ActiveRuleDto().setId(5).setProfileId(1).setRuleId(10).setSeverity(1)
+ .setNoteData("My note").setNoteUserLogin("nicolas").setNoteCreatedAt(createdAt).setNoteUpdatedAt(createdAt);
+
+ List<ActiveRuleParamDto> activeRuleParams = newArrayList(new ActiveRuleParamDto());
+ when(activeRuleDao.selectParamsByActiveRuleId(eq(5), eq(session))).thenReturn(activeRuleParams);
+
+ long now = System.currentTimeMillis();
+ doReturn(now).when(system).now();
+
+ operations.deleteActiveRuleNote(activeRule, authorizedUserSession);
+
+ ArgumentCaptor<ActiveRuleDto> argumentCaptor = ArgumentCaptor.forClass(ActiveRuleDto.class);
+ verify(activeRuleDao).update(argumentCaptor.capture());
+ assertThat(argumentCaptor.getValue().getNoteData()).isNull();
+ assertThat(argumentCaptor.getValue().getNoteUserLogin()).isNull();
+ assertThat(argumentCaptor.getValue().getNoteCreatedAt()).isNull();
+ assertThat(argumentCaptor.getValue().getNoteUpdatedAt()).isNull();
+
+ verify(session).commit();
+ verify(ruleRegistry).save(eq(activeRule), eq(activeRuleParams));
+ }
+
+}
package org.sonar.server.qualityprofile;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps;
import com.google.common.collect.Multimap;
import org.apache.ibatis.session.SqlSession;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.runners.MockitoJUnitRunner;
import org.mockito.stubbing.Answer;
-import org.sonar.api.PropertyType;
import org.sonar.api.profiles.ProfileImporter;
import org.sonar.api.profiles.RulesProfile;
-import org.sonar.api.rule.Severity;
import org.sonar.api.rules.ActiveRule;
import org.sonar.api.rules.Rule;
import org.sonar.api.rules.RulePriority;
-import org.sonar.api.utils.DateUtils;
import org.sonar.api.utils.System2;
import org.sonar.api.utils.ValidationMessages;
-import org.sonar.check.Cardinality;
import org.sonar.core.permission.GlobalPermissions;
import org.sonar.core.persistence.MyBatis;
import org.sonar.core.preview.PreviewCache;
import org.sonar.core.properties.PropertyDto;
import org.sonar.core.qualityprofile.db.*;
import org.sonar.core.rule.RuleDao;
-import org.sonar.core.rule.RuleDto;
-import org.sonar.core.rule.RuleParamDto;
-import org.sonar.server.configuration.ProfilesManager;
import org.sonar.server.exceptions.BadRequestException;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.rule.RuleRegistry;
import org.sonar.server.user.UserSession;
import java.io.Reader;
-import java.util.Date;
import java.util.List;
import java.util.Map;
import static org.fest.assertions.Assertions.assertThat;
import static org.fest.assertions.Fail.fail;
import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyInt;
-import static org.mockito.Matchers.anyList;
import static org.mockito.Matchers.anyListOf;
import static org.mockito.Matchers.eq;
-import static org.mockito.Matchers.isA;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
@Mock
RuleRegistry ruleRegistry;
- @Mock
- ProfilesManager profilesManager;
-
@Mock
System2 system;
}
}).when(activeRuleDao).insert(any(ActiveRuleDto.class), any(SqlSession.class));
- operations = new QProfileOperations(myBatis, qualityProfileDao, activeRuleDao, ruleDao, propertiesDao, importers, dryRunCache, ruleRegistry, profilesManager,
- system);
+ operations = new QProfileOperations(myBatis, qualityProfileDao, activeRuleDao, ruleDao, propertiesDao, importers, dryRunCache, ruleRegistry, system);
}
@Test
assertThat(argumentCaptor.getValue().getValue()).isEqualTo("My profile");
}
- @Test
- public void activate_rule() throws Exception {
- QualityProfileDto qualityProfile = new QualityProfileDto().setId(1).setName("My profile").setLanguage("java");
- RuleDto rule = new RuleDto().setId(10).setRepositoryKey("squid").setRuleKey("AvoidCycle");
- when(ruleDao.selectParameters(eq(10), eq(session))).thenReturn(newArrayList(new RuleParamDto().setId(20).setName("max").setDefaultValue("10")));
- final int idActiveRuleToUpdate = 42;
- final int idActiveRuleToDelete = 24;
- RuleInheritanceActions inheritanceActions = new RuleInheritanceActions()
- .addToIndex(idActiveRuleToUpdate)
- .addToDelete(idActiveRuleToDelete);
- when(profilesManager.activated(eq(1), anyInt(), eq("Nicolas"))).thenReturn(inheritanceActions);
- when(activeRuleDao.selectByIds(anyList(), isA(SqlSession.class))).thenReturn(ImmutableList.<ActiveRuleDto>of(mock(ActiveRuleDto.class)));
- when(activeRuleDao.selectParamsByActiveRuleIds(anyList(), isA(SqlSession.class))).thenReturn(ImmutableList.<ActiveRuleParamDto>of(mock(ActiveRuleParamDto.class)));
-
- ActiveRuleDto result = operations.createActiveRule(qualityProfile, rule, Severity.CRITICAL, authorizedUserSession);
- assertThat(result).isNotNull();
-
- ArgumentCaptor<ActiveRuleDto> activeRuleArgument = ArgumentCaptor.forClass(ActiveRuleDto.class);
- verify(activeRuleDao).insert(activeRuleArgument.capture(), eq(session));
- assertThat(activeRuleArgument.getValue().getRulId()).isEqualTo(10);
- assertThat(activeRuleArgument.getValue().getSeverity()).isEqualTo(3);
-
- ArgumentCaptor<ActiveRuleParamDto> activeRuleParamArgument = ArgumentCaptor.forClass(ActiveRuleParamDto.class);
- verify(activeRuleDao).insert(activeRuleParamArgument.capture(), eq(session));
- assertThat(activeRuleParamArgument.getValue().getKey()).isEqualTo("max");
- assertThat(activeRuleParamArgument.getValue().getValue()).isEqualTo("10");
-
- verify(session).commit();
- verify(profilesManager).activated(eq(1), anyInt(), eq("Nicolas"));
- verify(ruleRegistry).bulkIndexActiveRules(anyList(), isA(Multimap.class));
- }
-
- @Test
- public void update_severity() throws Exception {
- Rule rule = Rule.create().setRepositoryKey("squid").setKey("AvoidCycle");
- rule.setId(10);
- ActiveRuleDto activeRule = new ActiveRuleDto().setId(5).setProfileId(1).setRuleId(10).setSeverity(1);
- when(profilesManager.ruleSeverityChanged(eq(1), eq(5), eq(RulePriority.MINOR), eq(RulePriority.MAJOR), eq("Nicolas"))).thenReturn(new RuleInheritanceActions());
-
- operations.updateSeverity(activeRule, Severity.MAJOR, authorizedUserSession);
-
- verify(activeRuleDao).update(eq(activeRule), eq(session));
- verify(session).commit();
- verify(profilesManager).ruleSeverityChanged(eq(1), eq(5), eq(RulePriority.MINOR), eq(RulePriority.MAJOR), eq("Nicolas"));
- verify(ruleRegistry).bulkIndexActiveRules(anyList(), isA(Multimap.class));
- }
-
- @Test
- public void fail_to_update_severity_on_invalid_severity() throws Exception {
- Rule rule = Rule.create().setRepositoryKey("squid").setKey("AvoidCycle");
- rule.setId(10);
- ActiveRuleDto activeRule = new ActiveRuleDto().setId(5).setProfileId(1).setRuleId(10).setSeverity(1);
-
- try {
- operations.updateSeverity(activeRule, "Unknown", authorizedUserSession);
- fail();
- } catch (Exception e) {
- assertThat(e).isInstanceOf(BadRequestException.class);
- }
- verify(activeRuleDao, never()).update(eq(activeRule), eq(session));
- verifyZeroInteractions(profilesManager);
- }
-
- @Test
- public void deactivate_rule() throws Exception {
- ActiveRuleDto activeRule = new ActiveRuleDto().setId(5).setProfileId(1).setRuleId(10).setSeverity(1);
- when(activeRuleDao.selectByProfileAndRule(1, 10)).thenReturn(activeRule);
- when(profilesManager.deactivated(eq(1), anyInt(), eq("Nicolas"))).thenReturn(new RuleInheritanceActions());
-
- operations.deactivateRule(activeRule, authorizedUserSession);
-
- verify(activeRuleDao).delete(eq(5), eq(session));
- verify(activeRuleDao).deleteParameters(eq(5), eq(session));
- verify(session).commit();
- verify(profilesManager).deactivated(eq(1), anyInt(), eq("Nicolas"));
- verify(ruleRegistry).bulkIndexActiveRules(anyList(), isA(Multimap.class));
- }
-
- @Test
- public void update_active_rule_param() throws Exception {
- ActiveRuleDto activeRule = new ActiveRuleDto().setId(5).setProfileId(1).setRuleId(10).setSeverity(1);
- ActiveRuleParamDto activeRuleParam = new ActiveRuleParamDto().setId(100).setActiveRuleId(5).setKey("max").setValue("20");
-
- RuleParamDto ruleParam = new RuleParamDto().setRuleId(10).setName("max").setDefaultValue("20").setType(PropertyType.INTEGER.name());
- when(ruleDao.selectParamByRuleAndKey(10, "max", session)).thenReturn(ruleParam);
-
- when(profilesManager.ruleParamChanged(eq(1), eq(5), eq("max"), eq("20"), eq("30"), eq("Nicolas"))).thenReturn(new RuleInheritanceActions());
-
- operations.updateActiveRuleParam(activeRule, activeRuleParam, "30", authorizedUserSession);
-
- ArgumentCaptor<ActiveRuleParamDto> argumentCaptor = ArgumentCaptor.forClass(ActiveRuleParamDto.class);
- verify(activeRuleDao).update(argumentCaptor.capture(), eq(session));
- assertThat(argumentCaptor.getValue().getId()).isEqualTo(100);
- assertThat(argumentCaptor.getValue().getValue()).isEqualTo("30");
-
- verify(session).commit();
- verify(profilesManager).ruleParamChanged(eq(1), eq(5), eq("max"), eq("20"), eq("30"), eq("Nicolas"));
- verify(ruleRegistry).bulkIndexActiveRules(anyList(), isA(Multimap.class));
- }
-
- @Test
- public void remove_active_rule_param() throws Exception {
- ActiveRuleDto activeRule = new ActiveRuleDto().setId(5).setProfileId(1).setRuleId(10).setSeverity(1);
- ActiveRuleParamDto activeRuleParam = new ActiveRuleParamDto().setId(100).setActiveRuleId(5).setKey("max").setValue("20");
- when(profilesManager.ruleParamChanged(eq(1), eq(5), eq("max"), eq("20"), eq((String) null), eq("Nicolas"))).thenReturn(new RuleInheritanceActions());
-
- operations.deleteActiveRuleParam(activeRule, activeRuleParam, authorizedUserSession);
-
- verify(session).commit();
- verify(activeRuleDao).deleteParameter(100, session);
- verify(profilesManager).ruleParamChanged(eq(1), eq(5), eq("max"), eq("20"), eq((String) null), eq("Nicolas"));
- verify(ruleRegistry).bulkIndexActiveRules(anyList(), isA(Multimap.class));
- }
-
- @Test
- public void create_active_rule_param() throws Exception {
- ActiveRuleDto activeRule = new ActiveRuleDto().setId(5).setProfileId(1).setRuleId(10).setSeverity(1);
- RuleParamDto ruleParam = new RuleParamDto().setRuleId(10).setName("max").setDefaultValue("20").setType(PropertyType.INTEGER.name());
- when(ruleDao.selectParamByRuleAndKey(10, "max", session)).thenReturn(ruleParam);
- when(profilesManager.ruleParamChanged(eq(1), eq(5), eq("max"), eq((String) null), eq("30"), eq("Nicolas"))).thenReturn(new RuleInheritanceActions());
-
- operations.createActiveRuleParam(activeRule, "max", "30", authorizedUserSession);
-
- ArgumentCaptor<ActiveRuleParamDto> argumentCaptor = ArgumentCaptor.forClass(ActiveRuleParamDto.class);
- verify(activeRuleDao).insert(argumentCaptor.capture(), eq(session));
- assertThat(argumentCaptor.getValue().getKey()).isEqualTo("max");
- assertThat(argumentCaptor.getValue().getValue()).isEqualTo("30");
- assertThat(argumentCaptor.getValue().getActiveRuleId()).isEqualTo(5);
-
- verify(session).commit();
- verify(profilesManager).ruleParamChanged(eq(1), eq(5), eq("max"), eq((String) null), eq("30"), eq("Nicolas"));
- verify(ruleRegistry).bulkIndexActiveRules(anyList(), isA(Multimap.class));
- }
-
- @Test
- public void fail_to_create_active_rule_if_no_rule_param() throws Exception {
- ActiveRuleDto activeRule = new ActiveRuleDto().setId(5).setProfileId(1).setRuleId(10).setSeverity(1);
- when(ruleDao.selectParamByRuleAndKey(10, "max", session)).thenReturn(null);
- try {
- operations.createActiveRuleParam(activeRule, "max", "30", authorizedUserSession);
- fail();
- } catch (Exception e) {
- assertThat(e).isInstanceOf(IllegalArgumentException.class);
- }
- verify(activeRuleDao, never()).insert(any(ActiveRuleParamDto.class), eq(session));
- verifyZeroInteractions(profilesManager);
- }
-
- @Test
- public void fail_to_create_active_rule_if_type_is_invalid() throws Exception {
- RuleParamDto ruleParam = new RuleParamDto().setRuleId(10).setName("max").setDefaultValue("20").setType(PropertyType.INTEGER.name());
- when(ruleDao.selectParamByRuleAndKey(10, "max", session)).thenReturn(ruleParam);
-
- ActiveRuleDto activeRule = new ActiveRuleDto().setId(5).setProfileId(1).setRuleId(10).setSeverity(1);
- try {
- operations.createActiveRuleParam(activeRule, "max", "invalid integer", authorizedUserSession);
- fail();
- } catch (Exception e) {
- assertThat(e).isInstanceOf(BadRequestException.class);
- }
- verify(activeRuleDao, never()).insert(any(ActiveRuleParamDto.class), eq(session));
- verifyZeroInteractions(profilesManager);
- }
-
- @Test
- public void update_active_rule_note_when_no_existing_note() throws Exception {
- ActiveRuleDto activeRule = new ActiveRuleDto().setId(5).setProfileId(1).setRuleId(10).setSeverity(1).setNoteCreatedAt(null).setNoteData(null);
-
- List<ActiveRuleParamDto> activeRuleParams = newArrayList(new ActiveRuleParamDto());
- when(activeRuleDao.selectParamsByActiveRuleId(eq(5), eq(session))).thenReturn(activeRuleParams);
-
- long now = System.currentTimeMillis();
- doReturn(now).when(system).now();
-
- operations.updateActiveRuleNote(activeRule, "My note", authorizedUserSession);
-
- ArgumentCaptor<ActiveRuleDto> argumentCaptor = ArgumentCaptor.forClass(ActiveRuleDto.class);
- verify(activeRuleDao).update(argumentCaptor.capture(), eq(session));
- assertThat(argumentCaptor.getValue().getNoteData()).isEqualTo("My note");
- assertThat(argumentCaptor.getValue().getNoteUserLogin()).isEqualTo("nicolas");
- assertThat(argumentCaptor.getValue().getNoteCreatedAt().getTime()).isEqualTo(now);
- assertThat(argumentCaptor.getValue().getNoteUpdatedAt().getTime()).isEqualTo(now);
-
- verify(session).commit();
- verify(ruleRegistry).save(eq(activeRule), eq(activeRuleParams));
- }
-
- @Test
- public void update_active_rule_note_when_already_note() throws Exception {
- Date createdAt = DateUtils.parseDate("2013-12-20");
- ActiveRuleDto activeRule = new ActiveRuleDto().setId(5).setProfileId(1).setRuleId(10).setSeverity(1)
- .setNoteCreatedAt(createdAt).setNoteData("My previous note").setNoteUserLogin("nicolas");
-
- List<ActiveRuleParamDto> activeRuleParams = newArrayList(new ActiveRuleParamDto());
- when(activeRuleDao.selectParamsByActiveRuleId(eq(5), eq(session))).thenReturn(activeRuleParams);
-
- long now = System.currentTimeMillis();
- doReturn(now).when(system).now();
-
- operations.updateActiveRuleNote(activeRule, "My new note", MockUserSession.create().setLogin("guy").setName("Guy").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN));
-
- ArgumentCaptor<ActiveRuleDto> argumentCaptor = ArgumentCaptor.forClass(ActiveRuleDto.class);
- verify(activeRuleDao).update(argumentCaptor.capture(), eq(session));
- assertThat(argumentCaptor.getValue().getNoteData()).isEqualTo("My new note");
- assertThat(argumentCaptor.getValue().getNoteUserLogin()).isEqualTo("nicolas");
- assertThat(argumentCaptor.getValue().getNoteCreatedAt()).isEqualTo(createdAt);
- assertThat(argumentCaptor.getValue().getNoteUpdatedAt().getTime()).isEqualTo(now);
-
- verify(session).commit();
- verify(ruleRegistry).save(eq(activeRule), eq(activeRuleParams));
- }
-
- @Test
- public void delete_active_rule_note() throws Exception {
- Date createdAt = DateUtils.parseDate("2013-12-20");
- ActiveRuleDto activeRule = new ActiveRuleDto().setId(5).setProfileId(1).setRuleId(10).setSeverity(1)
- .setNoteData("My note").setNoteUserLogin("nicolas").setNoteCreatedAt(createdAt).setNoteUpdatedAt(createdAt);
-
- List<ActiveRuleParamDto> activeRuleParams = newArrayList(new ActiveRuleParamDto());
- when(activeRuleDao.selectParamsByActiveRuleId(eq(5), eq(session))).thenReturn(activeRuleParams);
-
- long now = System.currentTimeMillis();
- doReturn(now).when(system).now();
-
- operations.deleteActiveRuleNote(activeRule, authorizedUserSession);
-
- ArgumentCaptor<ActiveRuleDto> argumentCaptor = ArgumentCaptor.forClass(ActiveRuleDto.class);
- verify(activeRuleDao).update(argumentCaptor.capture());
- assertThat(argumentCaptor.getValue().getNoteData()).isNull();
- assertThat(argumentCaptor.getValue().getNoteUserLogin()).isNull();
- assertThat(argumentCaptor.getValue().getNoteCreatedAt()).isNull();
- assertThat(argumentCaptor.getValue().getNoteUpdatedAt()).isNull();
-
- verify(session).commit();
- verify(ruleRegistry).save(eq(activeRule), eq(activeRuleParams));
- }
-
- @Test
- public void update_rule_note_when_no_existing_note() throws Exception {
- RuleDto rule = new RuleDto().setId(10).setNoteCreatedAt(null).setNoteData(null);
-
- List<RuleParamDto> ruleParams = newArrayList(new RuleParamDto().setId(20).setName("max").setDefaultValue("10"));
- when(ruleDao.selectParameters(eq(10), eq(session))).thenReturn(ruleParams);
-
- long now = System.currentTimeMillis();
- doReturn(now).when(system).now();
-
- operations.updateRuleNote(rule, "My note", authorizedUserSession);
-
- ArgumentCaptor<RuleDto> argumentCaptor = ArgumentCaptor.forClass(RuleDto.class);
- verify(ruleDao).update(argumentCaptor.capture());
- assertThat(argumentCaptor.getValue().getNoteData()).isEqualTo("My note");
- assertThat(argumentCaptor.getValue().getNoteUserLogin()).isEqualTo("nicolas");
- assertThat(argumentCaptor.getValue().getNoteCreatedAt().getTime()).isEqualTo(now);
- assertThat(argumentCaptor.getValue().getNoteUpdatedAt().getTime()).isEqualTo(now);
-
- verify(session).commit();
- verify(ruleRegistry).save(eq(rule), eq(ruleParams));
- }
-
- @Test
- public void update_rule_note_when_already_note() throws Exception {
- Date createdAt = DateUtils.parseDate("2013-12-20");
- RuleDto rule = new RuleDto().setId(10).setNoteCreatedAt(createdAt).setNoteData("My previous note").setNoteUserLogin("nicolas");
-
- List<RuleParamDto> ruleParams = newArrayList(new RuleParamDto().setId(20).setName("max").setDefaultValue("10"));
- when(ruleDao.selectParameters(eq(10), eq(session))).thenReturn(ruleParams);
-
- long now = System.currentTimeMillis();
- doReturn(now).when(system).now();
-
- operations.updateRuleNote(rule, "My new note", MockUserSession.create().setLogin("guy").setName("Guy").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN));
-
- ArgumentCaptor<RuleDto> argumentCaptor = ArgumentCaptor.forClass(RuleDto.class);
- verify(ruleDao).update(argumentCaptor.capture());
- assertThat(argumentCaptor.getValue().getNoteData()).isEqualTo("My new note");
- assertThat(argumentCaptor.getValue().getNoteUserLogin()).isEqualTo("nicolas");
- assertThat(argumentCaptor.getValue().getNoteCreatedAt()).isEqualTo(createdAt);
- assertThat(argumentCaptor.getValue().getNoteUpdatedAt().getTime()).isEqualTo(now);
-
- verify(session).commit();
- verify(ruleRegistry).save(eq(rule), eq(ruleParams));
- }
-
- @Test
- public void delete_rule_note() throws Exception {
- Date createdAt = DateUtils.parseDate("2013-12-20");
- RuleDto rule = new RuleDto().setId(10).setNoteData("My note").setNoteUserLogin("nicolas").setNoteCreatedAt(createdAt).setNoteUpdatedAt(createdAt);
-
- List<RuleParamDto> ruleParams = newArrayList(new RuleParamDto().setId(20).setName("max").setDefaultValue("10"));
- when(ruleDao.selectParameters(eq(10), eq(session))).thenReturn(ruleParams);
-
- long now = System.currentTimeMillis();
- doReturn(now).when(system).now();
-
- operations.deleteRuleNote(rule, authorizedUserSession);
-
- ArgumentCaptor<RuleDto> argumentCaptor = ArgumentCaptor.forClass(RuleDto.class);
- verify(ruleDao).update(argumentCaptor.capture());
- assertThat(argumentCaptor.getValue().getNoteData()).isNull();
- assertThat(argumentCaptor.getValue().getNoteUserLogin()).isNull();
- assertThat(argumentCaptor.getValue().getNoteCreatedAt()).isNull();
- assertThat(argumentCaptor.getValue().getNoteUpdatedAt()).isNull();
-
- verify(session).commit();
- verify(ruleRegistry).save(eq(rule), eq(ruleParams));
- }
-
- @Test
- public void create_rule() throws Exception {
- RuleDto templateRule = new RuleDto().setId(10).setRepositoryKey("squid").setRuleKey("AvoidCycle").setConfigKey("Xpath");
- when(ruleDao.selectParameters(eq(10), eq(session))).thenReturn(newArrayList(new RuleParamDto().setId(20).setName("max").setDefaultValue("10")));
-
- Map<String, String> paramsByKey = ImmutableMap.of("max", "20");
- RuleDto result = operations.createRule(templateRule, "My New Rule", Severity.BLOCKER, "Rule Description", paramsByKey, authorizedUserSession);
- assertThat(result).isNotNull();
-
- ArgumentCaptor<RuleDto> ruleArgument = ArgumentCaptor.forClass(RuleDto.class);
- verify(ruleDao).insert(ruleArgument.capture(), eq(session));
- assertThat(ruleArgument.getValue().getParentId()).isEqualTo(10);
- assertThat(ruleArgument.getValue().getName()).isEqualTo("My New Rule");
- assertThat(ruleArgument.getValue().getDescription()).isEqualTo("Rule Description");
- assertThat(ruleArgument.getValue().getSeverity()).isEqualTo(4);
- assertThat(ruleArgument.getValue().getConfigKey()).isEqualTo("Xpath");
- assertThat(ruleArgument.getValue().getRepositoryKey()).isEqualTo("squid");
- assertThat(ruleArgument.getValue().getRuleKey()).startsWith("AvoidCycle");
- assertThat(ruleArgument.getValue().getStatus()).isEqualTo("READY");
- assertThat(ruleArgument.getValue().getCardinality()).isEqualTo(Cardinality.SINGLE);
-
- ArgumentCaptor<RuleParamDto> ruleParamArgument = ArgumentCaptor.forClass(RuleParamDto.class);
- verify(ruleDao).insert(ruleParamArgument.capture(), eq(session));
- assertThat(ruleParamArgument.getValue().getName()).isEqualTo("max");
- assertThat(ruleParamArgument.getValue().getDefaultValue()).isEqualTo("20");
-
- verify(session).commit();
- verify(ruleRegistry).save(eq(ruleArgument.getValue()), eq(newArrayList(ruleParamArgument.getValue())));
- }
-
- @Test
- public void update_rule() throws Exception {
- RuleDto rule = new RuleDto().setId(11).setRepositoryKey("squid").setRuleKey("XPath_1387869254").setConfigKey("Xpath");
- when(ruleDao.selectParameters(eq(11), eq(session))).thenReturn(newArrayList(new RuleParamDto().setId(21).setName("max").setDefaultValue("20")));
-
- Map<String, String> paramsByKey = ImmutableMap.of("max", "21");
- operations.updateRule(rule, "Updated Rule", Severity.MAJOR, "Updated Description", paramsByKey, authorizedUserSession);
-
- ArgumentCaptor<RuleDto> ruleArgument = ArgumentCaptor.forClass(RuleDto.class);
- verify(ruleDao).update(ruleArgument.capture(), eq(session));
- assertThat(ruleArgument.getValue().getName()).isEqualTo("Updated Rule");
- assertThat(ruleArgument.getValue().getDescription()).isEqualTo("Updated Description");
- assertThat(ruleArgument.getValue().getSeverity()).isEqualTo(2);
-
- ArgumentCaptor<RuleParamDto> ruleParamArgument = ArgumentCaptor.forClass(RuleParamDto.class);
- verify(ruleDao).update(ruleParamArgument.capture(), eq(session));
- assertThat(ruleParamArgument.getValue().getDefaultValue()).isEqualTo("21");
-
- verify(session).commit();
- verify(ruleRegistry).save(eq(ruleArgument.getValue()), eq(newArrayList(ruleParamArgument.getValue())));
- }
-
- @Test
- public void delete_rule() throws Exception {
- RuleDto rule = new RuleDto().setId(11).setRepositoryKey("squid").setRuleKey("XPath_1387869254").setConfigKey("Xpath").setUpdatedAt(DateUtils.parseDate("2013-12-23"));
- RuleParamDto param = new RuleParamDto().setId(21).setName("max").setDefaultValue("20");
- when(ruleDao.selectParameters(eq(11), eq(session))).thenReturn(newArrayList(param));
-
- ActiveRuleDto activeRule = new ActiveRuleDto().setId(5).setProfileId(1).setRuleId(11).setSeverity(1);
- when(activeRuleDao.selectByRuleId(11)).thenReturn(newArrayList(activeRule));
-
- long now = System.currentTimeMillis();
- doReturn(now).when(system).now();
-
- operations.deleteRule(rule, authorizedUserSession);
-
- ArgumentCaptor<RuleDto> ruleArgument = ArgumentCaptor.forClass(RuleDto.class);
- verify(ruleDao).update(ruleArgument.capture(), eq(session));
- assertThat(ruleArgument.getValue().getStatus()).isEqualTo(Rule.STATUS_REMOVED);
- assertThat(ruleArgument.getValue().getUpdatedAt()).isEqualTo(new Date(now));
-
- verify(ruleRegistry).save(eq(ruleArgument.getValue()), eq(newArrayList(param)));
- verify(activeRuleDao).deleteParameters(eq(5), eq(session));
- verify(activeRuleDao).deleteFromRule(eq(11), eq(session));
- verify(session, times(2)).commit();
- verify(ruleRegistry).deleteActiveRules(newArrayList(5));
- }
-
}
--- /dev/null
+/*
+ * SonarQube, open source software quality management tool.
+ * Copyright (C) 2008-2013 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.server.qualityprofile;
+
+import com.google.common.collect.ImmutableMap;
+import org.apache.ibatis.session.SqlSession;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.mockito.stubbing.Answer;
+import org.sonar.api.rule.Severity;
+import org.sonar.api.rules.Rule;
+import org.sonar.api.utils.DateUtils;
+import org.sonar.api.utils.System2;
+import org.sonar.check.Cardinality;
+import org.sonar.core.permission.GlobalPermissions;
+import org.sonar.core.persistence.MyBatis;
+import org.sonar.core.qualityprofile.db.ActiveRuleDao;
+import org.sonar.core.qualityprofile.db.ActiveRuleDto;
+import org.sonar.core.rule.RuleDao;
+import org.sonar.core.rule.RuleDto;
+import org.sonar.core.rule.RuleParamDto;
+import org.sonar.server.exceptions.ForbiddenException;
+import org.sonar.server.rule.RuleRegistry;
+import org.sonar.server.user.MockUserSession;
+import org.sonar.server.user.UserSession;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+import static com.google.common.collect.Lists.newArrayList;
+import static org.fest.assertions.Assertions.assertThat;
+import static org.fest.assertions.Fail.fail;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.*;
+
+@RunWith(MockitoJUnitRunner.class)
+public class QProfileRuleOperationsTest {
+
+ @Mock
+ MyBatis myBatis;
+
+ @Mock
+ SqlSession session;
+
+ @Mock
+ ActiveRuleDao activeRuleDao;
+
+ @Mock
+ RuleDao ruleDao;
+
+ @Mock
+ RuleRegistry ruleRegistry;
+
+ @Mock
+ System2 system;
+
+ Integer currentId = 1;
+
+ UserSession authorizedUserSession = MockUserSession.create().setLogin("nicolas").setName("Nicolas").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ UserSession unauthorizedUserSession = MockUserSession.create().setLogin("nicolas").setName("Nicolas");
+
+ QProfileRuleOperations operations;
+
+ @Before
+ public void setUp() throws Exception {
+ when(myBatis.openSession()).thenReturn(session);
+
+ // Associate an id when inserting an object to simulate the db id generator
+ doAnswer(new Answer() {
+ public Object answer(InvocationOnMock invocation) {
+ Object[] args = invocation.getArguments();
+ ActiveRuleDto dto = (ActiveRuleDto) args[0];
+ dto.setId(currentId++);
+ return null;
+ }
+ }).when(activeRuleDao).insert(any(ActiveRuleDto.class), any(SqlSession.class));
+
+ operations = new QProfileRuleOperations(myBatis, activeRuleDao, ruleDao, ruleRegistry, system);
+ }
+
+ @Test
+ public void update_rule_note_when_no_existing_note() throws Exception {
+ RuleDto rule = new RuleDto().setId(10).setNoteCreatedAt(null).setNoteData(null);
+
+ List<RuleParamDto> ruleParams = newArrayList(new RuleParamDto().setId(20).setName("max").setDefaultValue("10"));
+ when(ruleDao.selectParameters(eq(10), eq(session))).thenReturn(ruleParams);
+
+ long now = System.currentTimeMillis();
+ doReturn(now).when(system).now();
+
+ operations.updateRuleNote(rule, "My note", authorizedUserSession);
+
+ ArgumentCaptor<RuleDto> argumentCaptor = ArgumentCaptor.forClass(RuleDto.class);
+ verify(ruleDao).update(argumentCaptor.capture());
+ assertThat(argumentCaptor.getValue().getNoteData()).isEqualTo("My note");
+ assertThat(argumentCaptor.getValue().getNoteUserLogin()).isEqualTo("nicolas");
+ assertThat(argumentCaptor.getValue().getNoteCreatedAt().getTime()).isEqualTo(now);
+ assertThat(argumentCaptor.getValue().getNoteUpdatedAt().getTime()).isEqualTo(now);
+
+ verify(session).commit();
+ verify(ruleRegistry).save(eq(rule), eq(ruleParams));
+ }
+
+ @Test
+ public void fail_to_update_rule_note_without_profile_admin_permission() throws Exception {
+ RuleDto rule = new RuleDto().setId(10).setRepositoryKey("squid").setRuleKey("AvoidCycle");
+
+ try {
+ operations.updateRuleNote(rule, "My note", unauthorizedUserSession);
+ fail();
+ } catch (Exception e) {
+ assertThat(e).isInstanceOf(ForbiddenException.class);
+ }
+ verifyNoMoreInteractions(ruleDao);
+ verify(session, never()).commit();
+ }
+
+ @Test
+ public void update_rule_note_when_already_note() throws Exception {
+ Date createdAt = DateUtils.parseDate("2013-12-20");
+ RuleDto rule = new RuleDto().setId(10).setNoteCreatedAt(createdAt).setNoteData("My previous note").setNoteUserLogin("nicolas");
+
+ List<RuleParamDto> ruleParams = newArrayList(new RuleParamDto().setId(20).setName("max").setDefaultValue("10"));
+ when(ruleDao.selectParameters(eq(10), eq(session))).thenReturn(ruleParams);
+
+ long now = System.currentTimeMillis();
+ doReturn(now).when(system).now();
+
+ operations.updateRuleNote(rule, "My new note", MockUserSession.create().setLogin("guy").setName("Guy").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN));
+
+ ArgumentCaptor<RuleDto> argumentCaptor = ArgumentCaptor.forClass(RuleDto.class);
+ verify(ruleDao).update(argumentCaptor.capture());
+ assertThat(argumentCaptor.getValue().getNoteData()).isEqualTo("My new note");
+ assertThat(argumentCaptor.getValue().getNoteUserLogin()).isEqualTo("nicolas");
+ assertThat(argumentCaptor.getValue().getNoteCreatedAt()).isEqualTo(createdAt);
+ assertThat(argumentCaptor.getValue().getNoteUpdatedAt().getTime()).isEqualTo(now);
+
+ verify(session).commit();
+ verify(ruleRegistry).save(eq(rule), eq(ruleParams));
+ }
+
+ @Test
+ public void delete_rule_note() throws Exception {
+ Date createdAt = DateUtils.parseDate("2013-12-20");
+ RuleDto rule = new RuleDto().setId(10).setNoteData("My note").setNoteUserLogin("nicolas").setNoteCreatedAt(createdAt).setNoteUpdatedAt(createdAt);
+
+ List<RuleParamDto> ruleParams = newArrayList(new RuleParamDto().setId(20).setName("max").setDefaultValue("10"));
+ when(ruleDao.selectParameters(eq(10), eq(session))).thenReturn(ruleParams);
+
+ long now = System.currentTimeMillis();
+ doReturn(now).when(system).now();
+
+ operations.deleteRuleNote(rule, authorizedUserSession);
+
+ ArgumentCaptor<RuleDto> argumentCaptor = ArgumentCaptor.forClass(RuleDto.class);
+ verify(ruleDao).update(argumentCaptor.capture());
+ assertThat(argumentCaptor.getValue().getNoteData()).isNull();
+ assertThat(argumentCaptor.getValue().getNoteUserLogin()).isNull();
+ assertThat(argumentCaptor.getValue().getNoteCreatedAt()).isNull();
+ assertThat(argumentCaptor.getValue().getNoteUpdatedAt()).isNull();
+
+ verify(session).commit();
+ verify(ruleRegistry).save(eq(rule), eq(ruleParams));
+ }
+
+ @Test
+ public void create_rule() throws Exception {
+ RuleDto templateRule = new RuleDto().setId(10).setRepositoryKey("squid").setRuleKey("AvoidCycle").setConfigKey("Xpath");
+ when(ruleDao.selectParameters(eq(10), eq(session))).thenReturn(newArrayList(new RuleParamDto().setId(20).setName("max").setDefaultValue("10")));
+
+ Map<String, String> paramsByKey = ImmutableMap.of("max", "20");
+ RuleDto result = operations.createRule(templateRule, "My New Rule", Severity.BLOCKER, "Rule Description", paramsByKey, authorizedUserSession);
+ assertThat(result).isNotNull();
+
+ ArgumentCaptor<RuleDto> ruleArgument = ArgumentCaptor.forClass(RuleDto.class);
+ verify(ruleDao).insert(ruleArgument.capture(), eq(session));
+ assertThat(ruleArgument.getValue().getParentId()).isEqualTo(10);
+ assertThat(ruleArgument.getValue().getName()).isEqualTo("My New Rule");
+ assertThat(ruleArgument.getValue().getDescription()).isEqualTo("Rule Description");
+ assertThat(ruleArgument.getValue().getSeverity()).isEqualTo(4);
+ assertThat(ruleArgument.getValue().getConfigKey()).isEqualTo("Xpath");
+ assertThat(ruleArgument.getValue().getRepositoryKey()).isEqualTo("squid");
+ assertThat(ruleArgument.getValue().getRuleKey()).startsWith("AvoidCycle");
+ assertThat(ruleArgument.getValue().getStatus()).isEqualTo("READY");
+ assertThat(ruleArgument.getValue().getCardinality()).isEqualTo(Cardinality.SINGLE);
+
+ ArgumentCaptor<RuleParamDto> ruleParamArgument = ArgumentCaptor.forClass(RuleParamDto.class);
+ verify(ruleDao).insert(ruleParamArgument.capture(), eq(session));
+ assertThat(ruleParamArgument.getValue().getName()).isEqualTo("max");
+ assertThat(ruleParamArgument.getValue().getDefaultValue()).isEqualTo("20");
+
+ verify(session).commit();
+ verify(ruleRegistry).save(eq(ruleArgument.getValue()), eq(newArrayList(ruleParamArgument.getValue())));
+ }
+
+ @Test
+ public void update_rule() throws Exception {
+ RuleDto rule = new RuleDto().setId(11).setRepositoryKey("squid").setRuleKey("XPath_1387869254").setConfigKey("Xpath");
+ when(ruleDao.selectParameters(eq(11), eq(session))).thenReturn(newArrayList(new RuleParamDto().setId(21).setName("max").setDefaultValue("20")));
+
+ Map<String, String> paramsByKey = ImmutableMap.of("max", "21");
+ operations.updateRule(rule, "Updated Rule", Severity.MAJOR, "Updated Description", paramsByKey, authorizedUserSession);
+
+ ArgumentCaptor<RuleDto> ruleArgument = ArgumentCaptor.forClass(RuleDto.class);
+ verify(ruleDao).update(ruleArgument.capture(), eq(session));
+ assertThat(ruleArgument.getValue().getName()).isEqualTo("Updated Rule");
+ assertThat(ruleArgument.getValue().getDescription()).isEqualTo("Updated Description");
+ assertThat(ruleArgument.getValue().getSeverity()).isEqualTo(2);
+
+ ArgumentCaptor<RuleParamDto> ruleParamArgument = ArgumentCaptor.forClass(RuleParamDto.class);
+ verify(ruleDao).update(ruleParamArgument.capture(), eq(session));
+ assertThat(ruleParamArgument.getValue().getDefaultValue()).isEqualTo("21");
+
+ verify(session).commit();
+ verify(ruleRegistry).save(eq(ruleArgument.getValue()), eq(newArrayList(ruleParamArgument.getValue())));
+ }
+
+ @Test
+ public void delete_rule() throws Exception {
+ RuleDto rule = new RuleDto().setId(11).setRepositoryKey("squid").setRuleKey("XPath_1387869254").setConfigKey("Xpath").setUpdatedAt(DateUtils.parseDate("2013-12-23"));
+ RuleParamDto param = new RuleParamDto().setId(21).setName("max").setDefaultValue("20");
+ when(ruleDao.selectParameters(eq(11), eq(session))).thenReturn(newArrayList(param));
+
+ ActiveRuleDto activeRule = new ActiveRuleDto().setId(5).setProfileId(1).setRuleId(11).setSeverity(1);
+ when(activeRuleDao.selectByRuleId(11)).thenReturn(newArrayList(activeRule));
+
+ long now = System.currentTimeMillis();
+ doReturn(now).when(system).now();
+
+ operations.deleteRule(rule, authorizedUserSession);
+
+ ArgumentCaptor<RuleDto> ruleArgument = ArgumentCaptor.forClass(RuleDto.class);
+ verify(ruleDao).update(ruleArgument.capture(), eq(session));
+ assertThat(ruleArgument.getValue().getStatus()).isEqualTo(Rule.STATUS_REMOVED);
+ assertThat(ruleArgument.getValue().getUpdatedAt()).isEqualTo(new Date(now));
+
+ verify(ruleRegistry).save(eq(ruleArgument.getValue()), eq(newArrayList(param)));
+ verify(activeRuleDao).deleteParameters(eq(5), eq(session));
+ verify(activeRuleDao).deleteFromRule(eq(11), eq(session));
+ verify(session, times(2)).commit();
+ verify(ruleRegistry).deleteActiveRules(newArrayList(5));
+ }
+
+}
@Mock
QProfileOperations service;
+ @Mock
+ QProfileActiveRuleOperations activeRuleOperations;
+
+ @Mock
+ QProfileRuleOperations ruleOperations;
+
@Mock
ProfileRules rules;
@Before
public void setUp() throws Exception {
- qProfiles = new QProfiles(qualityProfileDao, activeRuleDao, ruleDao, resourceDao, projectService, search, service, rules);
+ qProfiles = new QProfiles(qualityProfileDao, activeRuleDao, ruleDao, resourceDao, projectService, search, service, activeRuleOperations, ruleOperations, rules);
}
@Test
RuleDto rule = new RuleDto().setId(10).setRepositoryKey("squid").setRuleKey("AvoidCycle");
when(ruleDao.selectById(10)).thenReturn(rule);
- when(service.createActiveRule(eq(qualityProfile), eq(rule), eq(Severity.BLOCKER), any(UserSession.class)))
+ when(activeRuleOperations.createActiveRule(eq(qualityProfile), eq(rule), eq(Severity.BLOCKER), any(UserSession.class)))
.thenReturn(new ActiveRuleDto().setId(5).setProfileId(1).setRuleId(10).setSeverity(1));
qProfiles.activateRule(1, 10, Severity.BLOCKER);
- verify(service).createActiveRule(eq(qualityProfile), eq(rule), eq(Severity.BLOCKER), any(UserSession.class));
+ verify(activeRuleOperations).createActiveRule(eq(qualityProfile), eq(rule), eq(Severity.BLOCKER), any(UserSession.class));
}
@Test
qProfiles.activateRule(1, 10, Severity.BLOCKER);
- verify(service).updateSeverity(eq(activeRule), eq(Severity.BLOCKER), any(UserSession.class));
+ verify(activeRuleOperations).updateSeverity(eq(activeRule), eq(Severity.BLOCKER), any(UserSession.class));
}
@Test
qProfiles.deactivateRule(1, 10);
- verify(service).deactivateRule(eq(activeRule), any(UserSession.class));
+ verify(activeRuleOperations).deactivateRule(eq(activeRule), any(UserSession.class));
}
@Test
qProfiles.updateActiveRuleParam(1, 50, "max", "20");
- verify(service).updateActiveRuleParam(eq(activeRule), eq(activeRuleParam), eq("20"), any(UserSession.class));
+ verify(activeRuleOperations).updateActiveRuleParam(eq(activeRule), eq(activeRuleParam), eq("20"), any(UserSession.class));
}
@Test
qProfiles.updateActiveRuleParam(1, 50, "max", "20");
- verify(service).createActiveRuleParam(eq(activeRule), eq("max"), eq("20"), any(UserSession.class));
+ verify(activeRuleOperations).createActiveRuleParam(eq(activeRule), eq("max"), eq("20"), any(UserSession.class));
}
@Test
qProfiles.updateActiveRuleParam(1, 50, "max", "");
- verify(service).deleteActiveRuleParam(eq(activeRule), eq(activeRuleParam), any(UserSession.class));
+ verify(activeRuleOperations).deleteActiveRuleParam(eq(activeRule), eq(activeRuleParam), any(UserSession.class));
}
@Test
qProfiles.updateActiveRuleNote(50, "My note");
- verify(service).updateActiveRuleNote(eq(activeRule), eq("My note"), any(UserSession.class));
+ verify(activeRuleOperations).updateActiveRuleNote(eq(activeRule), eq("My note"), any(UserSession.class));
}
@Test
qProfiles.updateActiveRuleNote(50, "");
- verify(service, never()).updateActiveRuleNote(eq(activeRule), anyString(), any(UserSession.class));
+ verify(activeRuleOperations, never()).updateActiveRuleNote(eq(activeRule), anyString(), any(UserSession.class));
}
@Test
qProfiles.deleteActiveRuleNote(50);
- verify(service).deleteActiveRuleNote(eq(activeRule), any(UserSession.class));
+ verify(activeRuleOperations).deleteActiveRuleNote(eq(activeRule), any(UserSession.class));
}
@Test
qProfiles.updateRuleNote(50, 10, "My note");
- verify(service).updateRuleNote(eq(rule), eq("My note"), any(UserSession.class));
+ verify(ruleOperations).updateRuleNote(eq(rule), eq("My note"), any(UserSession.class));
}
@Test
qProfiles.updateRuleNote(50, 10, "");
- verify(service).deleteRuleNote(eq(rule), any(UserSession.class));
+ verify(ruleOperations).deleteRuleNote(eq(rule), any(UserSession.class));
}
@Test
RuleDto newRule = new RuleDto().setId(11);
Map<String, String> paramsByKey = ImmutableMap.of("max", "20");
- when(service.createRule(eq(rule), eq("Rule name"), eq(Severity.MAJOR), eq("My note"), eq(paramsByKey), any(UserSession.class))).thenReturn(newRule);
+ when(ruleOperations.createRule(eq(rule), eq("Rule name"), eq(Severity.MAJOR), eq("My note"), eq(paramsByKey), any(UserSession.class))).thenReturn(newRule);
qProfiles.createRule(10, "Rule name", Severity.MAJOR, "My note", paramsByKey);
- verify(service).createRule(eq(rule), eq("Rule name"), eq(Severity.MAJOR), eq("My note"), eq(paramsByKey), any(UserSession.class));
+ verify(ruleOperations).createRule(eq(rule), eq("Rule name"), eq(Severity.MAJOR), eq("My note"), eq(paramsByKey), any(UserSession.class));
verify(rules).getFromRuleId(11);
}
RuleDto newRule = new RuleDto().setId(11);
Map<String, String> paramsByKey = ImmutableMap.of("max", "20");
- when(service.createRule(eq(rule), eq("Rule name"), eq(Severity.MAJOR), eq("My note"), eq(paramsByKey), any(UserSession.class))).thenReturn(newRule);
+ when(ruleOperations.createRule(eq(rule), eq("Rule name"), eq(Severity.MAJOR), eq("My note"), eq(paramsByKey), any(UserSession.class))).thenReturn(newRule);
try {
qProfiles.createRule( 10, "", "", "", paramsByKey);
RuleDto newRule = new RuleDto().setId(11);
Map<String, String> paramsByKey = ImmutableMap.of("max", "20");
- when(service.createRule(eq(rule), eq("Rule name"), eq(Severity.MAJOR), eq("My description"), eq(paramsByKey), any(UserSession.class))).thenReturn(newRule);
+ when(ruleOperations.createRule(eq(rule), eq("Rule name"), eq(Severity.MAJOR), eq("My description"), eq(paramsByKey), any(UserSession.class))).thenReturn(newRule);
try {
qProfiles.createRule(10, "Rule name", Severity.MAJOR, "My description", paramsByKey);
qProfiles.updateRule(11, "Updated name", Severity.MAJOR, "Updated description", paramsByKey);
- verify(service).updateRule(eq(rule), eq("Updated name"), eq(Severity.MAJOR), eq("Updated description"), eq(paramsByKey), any(UserSession.class));
+ verify(ruleOperations).updateRule(eq(rule), eq("Updated name"), eq(Severity.MAJOR), eq("Updated description"), eq(paramsByKey), any(UserSession.class));
verify(rules).getFromRuleId(11);
}
qProfiles.updateRule(11, "Rule name", Severity.MAJOR, "Updated description", paramsByKey);
- verify(service).updateRule(eq(rule), eq("Rule name"), eq(Severity.MAJOR), eq("Updated description"), eq(paramsByKey), any(UserSession.class));
+ verify(ruleOperations).updateRule(eq(rule), eq("Rule name"), eq(Severity.MAJOR), eq("Updated description"), eq(paramsByKey), any(UserSession.class));
verify(rules).getFromRuleId(11);
}
qProfiles.deleteRule(11);
- verify(service).deleteRule(eq(rule), any(UserSession.class));
+ verify(ruleOperations).deleteRule(eq(rule), any(UserSession.class));
}
@Test
projects / sonarqube.git / commitdiff