<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.sonarsource.parent</groupId>
<goal>compile</goal>
</goals>
<configuration>
- <protocArtifact>com.google.protobuf:protoc:${protobuf.version}:exe:${os.detected.classifier}</protocArtifact>
+ <protocArtifact>com.google.protobuf:protoc:${protobuf.version}:exe:${os.detected.classifier}
+ </protocArtifact>
<protoSourceRoot>${project.basedir}/src/main/protobuf</protoSourceRoot>
<outputDirectory>${project.build.directory}/generated-sources/protobuf</outputDirectory>
</configuration>
<goal>test-compile</goal>
</goals>
<configuration>
- <protocArtifact>com.google.protobuf:protoc:${protobuf.version}:exe:${os.detected.classifier}</protocArtifact>
+ <protocArtifact>com.google.protobuf:protoc:${protobuf.version}:exe:${os.detected.classifier}
+ </protocArtifact>
<protoTestSourceRoot>${project.basedir}/src/test/protobuf</protoTestSourceRoot>
<outputDirectory>${project.build.directory}/generated-test-sources/protobuf</outputDirectory>
</configuration>
import org.sonar.server.plugins.privileged.PrivilegedPluginsBootstraper;
import org.sonar.server.plugins.privileged.PrivilegedPluginsStopper;
import org.sonar.server.property.InternalPropertiesImpl;
-import org.sonar.server.qualityprofile.QProfileLookup;
import org.sonar.server.qualityprofile.index.ActiveRuleIndex;
import org.sonar.server.qualityprofile.index.ActiveRuleIndexer;
import org.sonar.server.rule.CommonRuleDefinitionsImpl;
XMLProfileSerializer.class,
AnnotationProfileParser.class,
Rules.QProfiles.class,
- QProfileLookup.class,
// rule
RuleIndexer.class,
assertThat(picoContainer.getComponentAdapters())
.hasSize(
CONTAINER_ITSELF
- + 79 // level 4
+ + 78 // level 4
+ 4 // content of CeConfigurationModule
+ 3 // content of CeHttpModule
+ 5 // content of CeQueueModule
*/
package org.sonar.db.component;
+import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import org.sonar.api.resources.Qualifiers;
import org.sonar.db.Dao;
import org.sonar.db.DbSession;
-import org.sonar.db.MyBatis;
import static com.google.common.base.Preconditions.checkArgument;
import static org.sonar.core.component.ComponentKeys.checkModuleKey;
* @since 3.2
*/
public class ComponentKeyUpdaterDao implements Dao {
- private static final Set<String> PROJECT_OR_MODULE_QUALIFIERS = ImmutableSet.of(Qualifiers.PROJECT, Qualifiers.MODULE);
-
- private MyBatis mybatis;
-
- public ComponentKeyUpdaterDao(MyBatis mybatis) {
- this.mybatis = mybatis;
- }
- public void updateKey(String projectUuid, String newKey) {
- try (DbSession session = mybatis.openSession(true)) {
- ComponentKeyUpdaterMapper mapper = session.getMapper(ComponentKeyUpdaterMapper.class);
- if (mapper.countResourceByKey(newKey) > 0) {
- throw new IllegalArgumentException("Impossible to update key: a component with key \"" + newKey + "\" already exists.");
- }
+ private static final Set<String> PROJECT_OR_MODULE_QUALIFIERS = ImmutableSet.of(Qualifiers.PROJECT, Qualifiers.MODULE);
- // must SELECT first everything
- ResourceDto project = mapper.selectProject(projectUuid);
- String projectOldKey = project.getKey();
- List<ResourceDto> resources = mapper.selectProjectResources(projectUuid);
- resources.add(project);
+ public void updateKey(DbSession dbSession, String projectUuid, String newKey) {
+ ComponentKeyUpdaterMapper mapper = dbSession.getMapper(ComponentKeyUpdaterMapper.class);
+ if (mapper.countResourceByKey(newKey) > 0) {
+ throw new IllegalArgumentException("Impossible to update key: a component with key \"" + newKey + "\" already exists.");
+ }
- // and then proceed with the batch UPDATE at once
- runBatchUpdateForAllResources(resources, projectOldKey, newKey, mapper);
+ // must SELECT first everything
+ ResourceDto project = mapper.selectProject(projectUuid);
+ String projectOldKey = project.getKey();
+ List<ResourceDto> resources = mapper.selectProjectResources(projectUuid);
+ resources.add(project);
- session.commit();
- }
- }
+ // and then proceed with the batch UPDATE at once
+ runBatchUpdateForAllResources(resources, projectOldKey, newKey, mapper);
- public Map<String, String> checkModuleKeysBeforeRenaming(String projectUuid, String stringToReplace, String replacementString) {
- try (DbSession session = mybatis.openSession(false)) {
- ComponentKeyUpdaterMapper mapper = session.getMapper(ComponentKeyUpdaterMapper.class);
- Map<String, String> result = Maps.newHashMap();
- Set<ResourceDto> modules = collectAllModules(projectUuid, stringToReplace, mapper);
- for (ResourceDto module : modules) {
- String newKey = computeNewKey(module.getKey(), stringToReplace, replacementString);
- if (mapper.countResourceByKey(newKey) > 0) {
- result.put(module.getKey(), "#duplicate_key#");
- } else {
- result.put(module.getKey(), newKey);
- }
- }
- return result;
- }
+ dbSession.commit();
}
public static void checkIsProjectOrModule(ComponentDto component) {
return newComponentKeys.stream().collect(Collectors.toMap(Function.identity(), key -> mapper(dbSession).countResourceByKey(key) > 0));
}
- public static String computeNewKey(String key, String stringToReplace, String replacementString) {
+ @VisibleForTesting
+ static String computeNewKey(String key, String stringToReplace, String replacementString) {
return key.replace(stringToReplace, replacementString);
}
import org.sonar.core.util.stream.Collectors;
import org.sonar.db.Dao;
import org.sonar.db.DbSession;
-import org.sonar.db.MyBatis;
import static java.util.Collections.singletonList;
import static org.sonar.db.DatabaseUtils.executeLargeInputs;
public class IssueChangeDao implements Dao {
- private final MyBatis mybatis;
-
- public IssueChangeDao(MyBatis mybatis) {
- this.mybatis = mybatis;
- }
-
public List<FieldDiffs> selectChangelogByIssue(DbSession session, String issueKey) {
return selectByTypeAndIssueKeys(session, singletonList(issueKey), IssueChangeDto.TYPE_FIELD_CHANGE)
.stream()
.collect(Collectors.toList());
}
- public List<IssueChangeDto> selectChangelogOfNonClosedIssuesByComponent(String componentUuid) {
- try (DbSession session = mybatis.openSession(false)) {
- IssueChangeMapper mapper = mapper(session);
- return mapper.selectChangelogOfNonClosedIssuesByComponent(componentUuid, IssueChangeDto.TYPE_FIELD_CHANGE);
- }
+ public List<IssueChangeDto> selectChangelogOfNonClosedIssuesByComponent(DbSession session, String componentUuid) {
+ IssueChangeMapper mapper = mapper(session);
+ return mapper.selectChangelogOfNonClosedIssuesByComponent(componentUuid, IssueChangeDto.TYPE_FIELD_CHANGE);
}
public List<IssueChangeDto> selectByTypeAndIssueKeys(DbSession session, Collection<String> issueKeys, String changeType) {
import org.sonar.db.Dao;
import org.sonar.db.DbSession;
-import org.sonar.db.MyBatis;
public class LoadedTemplateDao implements Dao {
- private MyBatis mybatis;
-
- public LoadedTemplateDao(MyBatis mybatis) {
- this.mybatis = mybatis;
- }
-
- public int countByTypeAndKey(String type, String key) {
- try (DbSession session = mybatis.openSession(false)) {
- return countByTypeAndKey(type, key, session);
- }
- }
-
public int countByTypeAndKey(String type, String key, DbSession session) {
return session.getMapper(LoadedTemplateMapper.class).countByTypeAndKey(type, key);
}
- public void insert(LoadedTemplateDto loadedTemplateDto) {
- try (DbSession session = mybatis.openSession(false)) {
- insert(loadedTemplateDto, session);
- session.commit();
- }
- }
-
public void insert(LoadedTemplateDto loadedTemplateDto, DbSession session) {
session.getMapper(LoadedTemplateMapper.class).insert(loadedTemplateDto);
}
import java.util.Date;
import org.sonar.db.Dao;
import org.sonar.db.DbSession;
-import org.sonar.db.MyBatis;
-/**
- * @since 4.3
- */
public class QualityGateConditionDao implements Dao {
- private final MyBatis myBatis;
-
- public QualityGateConditionDao(MyBatis myBatis) {
- this.myBatis = myBatis;
- }
-
public void insert(QualityGateConditionDto newQualityGate, DbSession session) {
mapper(session).insert(newQualityGate.setCreatedAt(new Date()));
}
- public Collection<QualityGateConditionDto> selectForQualityGate(long qGateId) {
- try (DbSession dbSession = myBatis.openSession(false)) {
- return selectForQualityGate(qGateId, dbSession);
- }
- }
-
- public Collection<QualityGateConditionDto> selectForQualityGate(long qGateId, DbSession session) {
+ public Collection<QualityGateConditionDto> selectForQualityGate(DbSession session, long qGateId) {
return mapper(session).selectForQualityGate(qGateId);
}
- public QualityGateConditionDto selectById(long id) {
- try (DbSession session = myBatis.openSession(false)) {
- return selectById(id, session);
- }
- }
-
public QualityGateConditionDto selectById(long id, DbSession session) {
return mapper(session).selectById(id);
}
- public void delete(QualityGateConditionDto qGate) {
- DbSession session = myBatis.openSession(false);
- try {
- delete(qGate, session);
- session.commit();
- } finally {
- MyBatis.closeQuietly(session);
- }
- }
-
public void delete(QualityGateConditionDto qGate, DbSession session) {
mapper(session).delete(qGate.getId());
}
- public void update(QualityGateConditionDto qGate) {
- try (DbSession dbSession = myBatis.openSession(false)) {
- update(qGate, dbSession);
- dbSession.commit();
- }
- }
-
public void update(QualityGateConditionDto qGate, DbSession session) {
mapper(session).update(qGate.setUpdatedAt(new Date()));
}
import javax.annotation.CheckForNull;
import org.sonar.db.Dao;
import org.sonar.db.DbSession;
-import org.sonar.db.MyBatis;
public class QualityGateDao implements Dao {
- private final MyBatis myBatis;
-
- public QualityGateDao(MyBatis myBatis) {
- this.myBatis = myBatis;
- }
-
- public void insert(QualityGateDto newQualityGate) {
- DbSession session = myBatis.openSession(false);
- try {
- insert(session, newQualityGate);
- session.commit();
- } finally {
- MyBatis.closeQuietly(session);
- }
- }
-
public QualityGateDto insert(DbSession session, QualityGateDto newQualityGate) {
mapper(session).insert(newQualityGate.setCreatedAt(new Date()));
return newQualityGate;
}
- public Collection<QualityGateDto> selectAll() {
- DbSession session = myBatis.openSession(false);
- try {
- return selectAll(session);
- } finally {
- MyBatis.closeQuietly(session);
- }
- }
-
public Collection<QualityGateDto> selectAll(DbSession session) {
return mapper(session).selectAll();
}
- @CheckForNull
- public QualityGateDto selectByName(String name) {
- DbSession session = myBatis.openSession(false);
- try {
- return selectByName(session, name);
- } finally {
- MyBatis.closeQuietly(session);
- }
- }
-
@CheckForNull
public QualityGateDto selectByName(DbSession session, String name) {
return mapper(session).selectByName(name);
}
- @CheckForNull
- public QualityGateDto selectById(long id) {
- DbSession session = myBatis.openSession(false);
- try {
- return selectById(session, id);
- } finally {
- MyBatis.closeQuietly(session);
- }
- }
-
@CheckForNull
public QualityGateDto selectById(DbSession session, long id) {
return mapper(session).selectById(id);
}
- public void delete(QualityGateDto qGate) {
- DbSession session = myBatis.openSession(false);
- try {
- delete(qGate, session);
- session.commit();
- } finally {
- MyBatis.closeQuietly(session);
- }
- }
-
public void delete(QualityGateDto qGate, DbSession session) {
mapper(session).delete(qGate.getId());
}
- public void update(QualityGateDto qGate) {
- DbSession session = myBatis.openSession(false);
- try {
- update(qGate, session);
- session.commit();
- } finally {
- MyBatis.closeQuietly(session);
- }
- }
-
public void update(QualityGateDto qGate, DbSession session) {
mapper(session).update(qGate.setUpdatedAt(new Date()));
}
import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
import java.util.Collection;
import java.util.Date;
+import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import org.sonar.api.utils.System2;
import org.sonar.db.Dao;
import org.sonar.db.DbSession;
-import org.sonar.db.MyBatis;
import org.sonar.db.RowNotFoundException;
import org.sonar.db.component.ComponentDto;
public class QualityProfileDao implements Dao {
- private final MyBatis mybatis;
private final System2 system;
- public QualityProfileDao(MyBatis mybatis, System2 system) {
- this.mybatis = mybatis;
+ public QualityProfileDao(System2 system) {
this.system = system;
}
mapper.insert(profile);
}
- /**
- * @deprecated use {@link #insert(DbSession, QualityProfileDto, QualityProfileDto...)}
- */
- @Deprecated
- public void insert(QualityProfileDto dto) {
- DbSession session = mybatis.openSession(false);
- try {
- insert(session, dto);
- session.commit();
- } finally {
- MyBatis.closeQuietly(session);
- }
- }
-
public void update(DbSession session, QualityProfileDto profile, QualityProfileDto... otherProfiles) {
QualityProfileMapper mapper = mapper(session);
doUpdate(mapper, profile);
mapper.delete(profileId);
}
- /**
- * @deprecated Replaced by {@link #selectAll(DbSession)}
- */
- @Deprecated
- public List<QualityProfileDto> selectAll() {
- DbSession session = mybatis.openSession(false);
- try {
- return mapper(session).selectAll();
- } finally {
- MyBatis.closeQuietly(session);
- }
- }
-
public List<QualityProfileDto> selectDefaultProfiles(DbSession session, Collection<String> languageKeys) {
return executeLargeInputs(languageKeys, mapper(session)::selectDefaultProfiles);
}
return mapper(session).selectDefaultProfile(language);
}
- @CheckForNull
- public QualityProfileDto selectDefaultProfile(String language) {
- DbSession session = mybatis.openSession(false);
- try {
- return selectDefaultProfile(session, language);
- } finally {
- MyBatis.closeQuietly(session);
- }
- }
-
- @CheckForNull
- public QualityProfileDto selectByProjectAndLanguage(long projectId, String language) {
- DbSession session = mybatis.openSession(false);
- try {
- return mapper(session).selectByProjectIdAndLanguage(projectId, language);
- } finally {
- MyBatis.closeQuietly(session);
- }
- }
-
@CheckForNull
public QualityProfileDto selectByProjectAndLanguage(DbSession session, String projectKey, String language) {
return mapper(session).selectByProjectAndLanguage(projectKey, language);
return executeLargeInputs(languageKeys, input -> mapper(session).selectByProjectAndLanguages(projectKey, input));
}
- public List<QualityProfileDto> selectByLanguage(String language) {
- DbSession session = mybatis.openSession(false);
- try {
- return mapper(session).selectByLanguage(language);
- } finally {
- MyBatis.closeQuietly(session);
- }
+ public List<QualityProfileDto> selectByLanguage(DbSession dbSession, String language) {
+ return mapper(dbSession).selectByLanguage(language);
}
@CheckForNull
return mapper(session).selectById(id);
}
- @CheckForNull
- public QualityProfileDto selectById(int id) {
- DbSession session = mybatis.openSession(false);
- try {
- return selectById(session, id);
- } finally {
- MyBatis.closeQuietly(session);
- }
- }
-
@CheckForNull
public QualityProfileDto selectParentById(DbSession session, int childId) {
return mapper(session).selectParentById(childId);
return executeLargeInputs(languageKeys, input -> mapper(session).selectByNameAndLanguages(name, input));
}
- public List<ComponentDto> selectProjects(String profileName, String language) {
- DbSession session = mybatis.openSession(false);
- try {
- return selectProjects(profileName, language, session);
- } finally {
- MyBatis.closeQuietly(session);
- }
- }
-
public List<ComponentDto> selectProjects(String profileName, String language, DbSession session) {
return mapper(session).selectProjects(profileName, language);
}
- public Map<String, Long> countProjectsByProfileKey() {
- DbSession session = mybatis.openSession(false);
- try {
- Map<String, Long> countByKey = Maps.newHashMap();
- for (QualityProfileProjectCount count : mapper(session).countProjectsByProfile()) {
- countByKey.put(count.getProfileKey(), count.getProjectCount());
- }
- return countByKey;
- } finally {
- MyBatis.closeQuietly(session);
+ public Map<String, Long> countProjectsByProfileKey(DbSession dbSession) {
+ Map<String, Long> countByKey = new HashMap<>();
+ QualityProfileMapper mapper = mapper(dbSession);
+ for (QualityProfileProjectCount count : mapper.countProjectsByProfile()) {
+ countByKey.put(count.getProfileKey(), count.getProjectCount());
}
+ return countByKey;
}
public void insertProjectProfileAssociation(String projectUuid, String profileKey, DbSession session) {
import org.apache.commons.io.IOUtils;
import org.sonar.db.Dao;
import org.sonar.db.DbSession;
-import org.sonar.db.MyBatis;
import org.sonar.db.source.FileSourceDto.Type;
public class FileSourceDao implements Dao {
private static final Splitter END_OF_LINE_SPLITTER = Splitter.on('\n');
- private final MyBatis mybatis;
-
- public FileSourceDao(MyBatis myBatis) {
- this.mybatis = myBatis;
- }
@CheckForNull
public FileSourceDto selectSourceByFileUuid(DbSession session, String fileUuid) {
}
@CheckForNull
- public FileSourceDto selectTest(String fileUuid) {
- DbSession session = mybatis.openSession(false);
- try {
- return mapper(session).select(fileUuid, Type.TEST);
- } finally {
- MyBatis.closeQuietly(session);
- }
+ public FileSourceDto selectTest(DbSession dbSession, String fileUuid) {
+ return mapper(dbSession).select(fileUuid, Type.TEST);
}
@CheckForNull
}
}
- public void insert(FileSourceDto dto) {
- DbSession session = mybatis.openSession(false);
- try {
- insert(session, dto);
- session.commit();
- } finally {
- MyBatis.closeQuietly(session);
- }
- }
-
public void insert(DbSession session, FileSourceDto dto) {
mapper(session).insert(dto);
}
- public void update(FileSourceDto dto) {
- DbSession session = mybatis.openSession(false);
- try {
- update(session, dto);
- session.commit();
- } finally {
- MyBatis.closeQuietly(session);
- }
- }
-
public void update(DbSession session, FileSourceDto dto) {
mapper(session).update(dto);
}
import org.sonar.api.utils.System2;
import org.sonar.db.Dao;
import org.sonar.db.DbSession;
-import org.sonar.db.MyBatis;
import org.sonar.db.RowNotFoundException;
import static com.google.common.collect.FluentIterable.from;
public class UserDao implements Dao {
- private final MyBatis mybatis;
private final System2 system2;
- public UserDao(MyBatis mybatis, System2 system2) {
- this.mybatis = mybatis;
+ public UserDao(System2 system2) {
this.system2 = system2;
}
- public UserDto selectUserById(int userId) {
- try (DbSession session = mybatis.openSession(false)) {
- return selectUserById(session, userId);
- }
- }
-
public UserDto selectUserById(DbSession session, int userId) {
return mapper(session).selectUser(userId);
}
return executeLargeInputs(ids, mapper(session)::selectByIds);
}
- /**
- * Search for user by login. Disabled users are ignored.
- *
- * @return the user, null if user not found
- */
- @CheckForNull
- public UserDto selectActiveUserByLogin(String login) {
- try (DbSession session = mybatis.openSession(false)) {
- return selectActiveUserByLogin(session, login);
- }
- }
-
@CheckForNull
public UserDto selectActiveUserByLogin(DbSession session, String login) {
UserMapper mapper = mapper(session);
return executeLargeInputs(logins, mapper(session)::selectByLogins);
}
- /**
- * @deprecated since 6.0 please use {@link #selectByLogins(DbSession, Collection)} instead
- */
- @Deprecated
- public List<UserDto> selectByLogins(Collection<String> logins) {
- try (DbSession session = mybatis.openSession(false)) {
- return selectByLogins(session, logins);
- }
- }
-
/**
* Gets a list users by their logins. The result does NOT contain {@code null} values for users not found, so
* the size of result may be less than the number of keys.
return from(logins).transform(new LoginToUser(unordered)).filter(Predicates.notNull()).toList();
}
- public List<UserDto> selectUsers(UserQuery query) {
- try (DbSession session = mybatis.openSession(false)) {
- return selectUsers(session, query);
- }
- }
-
public List<UserDto> selectUsers(DbSession dbSession, UserQuery query) {
return mapper(dbSession).selectUsers(query);
}
return mapper(dbSession).countByEmail(email.toLowerCase(Locale.ENGLISH)) > 0;
}
- protected UserMapper mapper(DbSession session) {
+ private static UserMapper mapper(DbSession session) {
return session.getMapper(UserMapper.class);
}
@Rule
public DbTester db = DbTester.create(System2.INSTANCE);
- DbClient dbClient = db.getDbClient();
- DbSession dbSession = db.getSession();
- ComponentKeyUpdaterDao underTest = db.getDbClient().componentKeyUpdaterDao();
+ private DbClient dbClient = db.getDbClient();
+ private DbSession dbSession = db.getSession();
+ private ComponentKeyUpdaterDao underTest = db.getDbClient().componentKeyUpdaterDao();
@Test
- public void shouldUpdateKey() {
+ public void updateKey_changes_the_key_of_tree_of_components() {
db.prepareDbUnit(getClass(), "shared.xml");
- underTest.updateKey("B", "struts:core");
+ underTest.updateKey(dbSession, "B", "struts:core");
db.assertDbUnit(getClass(), "shouldUpdateKey-result.xml", "projects");
}
@Test
- public void update_key_does_not_updated_inactive_components() {
+ public void updateKey_does_not_updated_inactive_components() {
OrganizationDto organizationDto = db.organizations().insert();
ComponentDto project = db.components().insertComponent(newProjectDto(organizationDto, "A").setKey("my_project"));
ComponentDto directory = db.components().insertComponent(newDirectory(project, "/directory").setKey("my_project:directory"));
ComponentDto inactiveDirectory = db.components().insertComponent(newDirectory(project, "/inactive_directory").setKey("my_project:inactive_directory").setEnabled(false));
db.components().insertComponent(newFileDto(project, inactiveDirectory).setKey("my_project:inactive_directory/file").setEnabled(false));
- underTest.updateKey("A", "your_project");
+ underTest.updateKey(dbSession, "A", "your_project");
db.commit();
List<ComponentDto> result = dbClient.componentDao().selectAllComponentsFromProjectKey(dbSession, "your_project");
}
@Test
- public void shouldNotUpdateKey() {
+ public void updateKey_throws_IAE_if_component_with_specified_key_does_not_exist() {
db.prepareDbUnit(getClass(), "shared.xml");
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("Impossible to update key: a component with key \"org.struts:struts-ui\" already exists.");
- underTest.updateKey("B", "org.struts:struts-ui");
+ underTest.updateKey(dbSession, "B", "org.struts:struts-ui");
}
@Test
}
@Test
- public void fail_with_functional_exception_when_sub_component_key_is_longer_than_authorized() {
+ public void updateKey_throws_IAE_when_sub_component_key_is_too_long() {
OrganizationDto organizationDto = db.organizations().insert();
ComponentDto project = newProjectDto(organizationDto, "project-uuid").setKey("old-project-key");
db.components().insertComponent(project);
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("Component key length (405) is longer than the maximum authorized (400). '" + newLongProjectKey + ":file' was provided.");
- underTest.updateKey(project.uuid(), newLongProjectKey);
+ underTest.updateKey(dbSession, project.uuid(), newLongProjectKey);
}
@Test
underTest.bulkUpdateKey(dbSession, project.uuid(), project.key(), "my?project?key");
}
- @Test
- public void shouldCheckModuleKeysBeforeRenaming() {
- db.prepareDbUnit(getClass(), "shared.xml");
-
- Map<String, String> checkResults = underTest.checkModuleKeysBeforeRenaming("A", "org.struts", "foo");
- assertThat(checkResults.size()).isEqualTo(3);
- assertThat(checkResults.get("org.struts:struts")).isEqualTo("foo:struts");
- assertThat(checkResults.get("org.struts:struts-core")).isEqualTo("#duplicate_key#");
- assertThat(checkResults.get("org.struts:struts-ui")).isEqualTo("foo:struts-ui");
- }
-
@Test
public void check_component_keys() {
db.prepareDbUnit(getClass(), "shared.xml");
public void selectChangelogOfNonClosedIssuesByComponent() {
db.prepareDbUnit(getClass(), "selectChangelogOfNonClosedIssuesByComponent.xml");
- List<IssueChangeDto> dtos = underTest.selectChangelogOfNonClosedIssuesByComponent("FILE_1");
+ List<IssueChangeDto> dtos = underTest.selectChangelogOfNonClosedIssuesByComponent(db.getSession(), "FILE_1");
// no need to have ordered results (see NewDebtCalculator)
assertThat(dtos).extracting("id").containsOnly(100L, 103L);
}
import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.utils.System2;
+import org.sonar.db.DbSession;
import org.sonar.db.DbTester;
-import static org.hamcrest.Matchers.is;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
public class LoadedTemplateDaoTest {
@Rule
public DbTester dbTester = DbTester.create(System2.INSTANCE);
- LoadedTemplateDao dao = dbTester.getDbClient().loadedTemplateDao();
+ private LoadedTemplateDao underTest = dbTester.getDbClient().loadedTemplateDao();
+ private DbSession dbSession = dbTester.getSession();
@Test
public void shouldCountByTypeAndKey() {
dbTester.prepareDbUnit(getClass(), "shouldCountByTypeAndKey.xml");
- assertThat(dao.countByTypeAndKey("DASHBOARD", "HOTSPOTS"), is(1));
- assertThat(dao.countByTypeAndKey("DASHBOARD", "UNKNOWN"), is(0));
- assertThat(dao.countByTypeAndKey("PROFILE", "HOTSPOTS"), is(0));
+ assertThat(underTest.countByTypeAndKey("DASHBOARD", "HOTSPOTS", dbSession)).isEqualTo(1);
+ assertThat(underTest.countByTypeAndKey("DASHBOARD", "UNKNOWN", dbSession)).isEqualTo(0);
+ assertThat(underTest.countByTypeAndKey("PROFILE", "HOTSPOTS", dbSession)).isEqualTo(0);
}
@Test
dbTester.prepareDbUnit(getClass(), "shouldInsert.xml");
LoadedTemplateDto template = new LoadedTemplateDto("SQALE", "DASHBOARD");
- dao.insert(template);
+ underTest.insert(template, dbSession);
+ dbSession.commit();
dbTester.assertDbUnit(getClass(), "shouldInsert-result.xml", "loaded_templates");
}
import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.utils.System2;
+import org.sonar.db.DbSession;
import org.sonar.db.DbTester;
import static org.assertj.core.api.Assertions.assertThat;
-
public class QualityGateConditionDaoTest {
private static final String[] COLUMNS_WITHOUT_TIMESTAMPS = {
@Rule
public DbTester dbTester = DbTester.create(System2.INSTANCE);
+ private DbSession dbSession = dbTester.getSession();
private QualityGateConditionDao underTest = dbTester.getDbClient().gateConditionDao();
@Test
@Test
public void testSelectForQualityGate() throws Exception {
dbTester.prepareDbUnit(getClass(), "selectForQualityGate.xml");
- assertThat(underTest.selectForQualityGate(1L)).hasSize(3);
- assertThat(underTest.selectForQualityGate(2L)).hasSize(2);
+ assertThat(underTest.selectForQualityGate(dbSession, 1L)).hasSize(3);
+ assertThat(underTest.selectForQualityGate(dbSession, 2L)).hasSize(2);
}
@Test
public void testSelectById() throws Exception {
dbTester.prepareDbUnit(getClass(), "selectForQualityGate.xml");
- QualityGateConditionDto selectById = underTest.selectById(1L);
+ QualityGateConditionDto selectById = underTest.selectById(1L, dbSession);
assertThat(selectById).isNotNull();
assertThat(selectById.getId()).isNotNull().isNotEqualTo(0L);
assertThat(selectById.getMetricId()).isEqualTo(2L);
assertThat(selectById.getQualityGateId()).isEqualTo(1L);
assertThat(selectById.getWarningThreshold()).isEqualTo("10");
assertThat(selectById.getErrorThreshold()).isEqualTo("20");
- assertThat(underTest.selectById(42L)).isNull();
+ assertThat(underTest.selectById(42L, dbSession)).isNull();
}
@Test
public void testDelete() throws Exception {
dbTester.prepareDbUnit(getClass(), "selectForQualityGate.xml");
- underTest.delete(new QualityGateConditionDto().setId(1L));
+
+ underTest.delete(new QualityGateConditionDto().setId(1L), dbSession);
+ dbSession.commit();
+
dbTester.assertDbUnitTable(getClass(), "delete-result.xml", "quality_gate_conditions", COLUMNS_WITHOUT_TIMESTAMPS);
}
@Test
public void testUpdate() throws Exception {
dbTester.prepareDbUnit(getClass(), "selectForQualityGate.xml");
- underTest.update(new QualityGateConditionDto().setId(1L).setMetricId(7L).setOperator(">").setPeriod(1).setWarningThreshold("50").setErrorThreshold("80"));
+
+ underTest.update(new QualityGateConditionDto().setId(1L).setMetricId(7L).setOperator(">").setPeriod(1).setWarningThreshold("50").setErrorThreshold("80"), dbSession);
+ dbSession.commit();
+
dbTester.assertDbUnitTable(getClass(), "update-result.xml", "quality_gate_conditions", COLUMNS_WITHOUT_TIMESTAMPS);
}
underTest.deleteConditionsWithInvalidMetrics(dbTester.getSession());
dbTester.commit();
-
- dbTester.assertDbUnit(getClass(), "shouldCleanConditions-result.xml", new String[]{"created_at", "updated_at"}, "quality_gate_conditions");
+
+ dbTester.assertDbUnit(getClass(), "shouldCleanConditions-result.xml", new String[] {"created_at", "updated_at"}, "quality_gate_conditions");
}
}
import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.utils.System2;
+import org.sonar.db.DbSession;
import org.sonar.db.DbTester;
import static org.assertj.core.api.Assertions.assertThat;
-
public class QualityGateDaoTest {
@Rule
public DbTester dbTester = DbTester.create(System2.INSTANCE);
- QualityGateDao dao = dbTester.getDbClient().qualityGateDao();
+ private DbSession dbSession = dbTester.getSession();
+ private QualityGateDao underTest = dbTester.getDbClient().qualityGateDao();
@Test
public void testInsert() throws Exception {
dbTester.prepareDbUnit(getClass(), "insert.xml");
QualityGateDto newQgate = new QualityGateDto().setName("My Quality Gate");
- dao.insert(newQgate);
+
+ underTest.insert(dbSession, newQgate);
+ dbSession.commit();
+
dbTester.assertDbUnitTable(getClass(), "insert-result.xml", "quality_gates", "name");
assertThat(newQgate.getId()).isNotNull();
}
@Test
public void testSelectAll() throws Exception {
dbTester.prepareDbUnit(getClass(), "selectAll.xml");
- Collection<QualityGateDto> allQualityGates = dao.selectAll();
+
+ Collection<QualityGateDto> allQualityGates = underTest.selectAll(dbSession);
+
assertThat(allQualityGates).hasSize(3);
Iterator<QualityGateDto> gatesIterator = allQualityGates.iterator();
assertThat(gatesIterator.next().getName()).isEqualTo("Balanced");
@Test
public void testSelectByName() throws Exception {
dbTester.prepareDbUnit(getClass(), "selectAll.xml");
- assertThat(dao.selectByName("Balanced").getName()).isEqualTo("Balanced");
- assertThat(dao.selectByName("Unknown")).isNull();
+ assertThat(underTest.selectByName(dbSession, "Balanced").getName()).isEqualTo("Balanced");
+ assertThat(underTest.selectByName(dbSession, "Unknown")).isNull();
}
@Test
public void testSelectById() throws Exception {
dbTester.prepareDbUnit(getClass(), "selectAll.xml");
- assertThat(dao.selectById(1L).getName()).isEqualTo("Very strict");
- assertThat(dao.selectById(42L)).isNull();
+ assertThat(underTest.selectById(dbSession, 1L).getName()).isEqualTo("Very strict");
+ assertThat(underTest.selectById(dbSession, 42L)).isNull();
}
@Test
public void testDelete() throws Exception {
dbTester.prepareDbUnit(getClass(), "selectAll.xml");
- dao.delete(new QualityGateDto().setId(1L));
+
+ underTest.delete(new QualityGateDto().setId(1L), dbSession);
+ dbSession.commit();
+
dbTester.assertDbUnitTable(getClass(), "delete-result.xml", "quality_gates", "id", "name");
}
@Test
public void testUpdate() throws Exception {
dbTester.prepareDbUnit(getClass(), "selectAll.xml");
- dao.update(new QualityGateDto().setId(1L).setName("Not so strict"));
+
+ underTest.update(new QualityGateDto().setId(1L).setName("Not so strict"), dbSession);
+ dbSession.commit();
+
dbTester.assertDbUnitTable(getClass(), "update-result.xml", "quality_gates", "id", "name");
}
}
.setName("ABCDE")
.setLanguage("xoo");
- underTest.insert(dto);
+ underTest.insert(dbTester.getSession(), dto);
+ dbTester.commit();
dbTester.assertDbUnit(getClass(), "insert-result.xml", new String[] {"created_at", "updated_at", "rules_updated_at"}, "rules_profiles");
}
public void find_all_is_sorted_by_profile_name() {
dbTester.prepareDbUnit(getClass(), "select_all_is_sorted_by_profile_name.xml");
- List<QualityProfileDto> dtos = underTest.selectAll();
+ List<QualityProfileDto> dtos = underTest.selectAll(dbTester.getSession());
assertThat(dtos).hasSize(3);
assertThat(dtos.get(0).getName()).isEqualTo("First");
public void get_default_profile() {
dbTester.prepareDbUnit(getClass(), "shared.xml");
- QualityProfileDto java = underTest.selectDefaultProfile("java");
+ QualityProfileDto java = underTest.selectDefaultProfile(dbTester.getSession(), "java");
assertThat(java).isNotNull();
assertThat(java.getKey()).isEqualTo("java_sonar_way");
- assertThat(underTest.selectDefaultProfile("js")).isNull();
+ assertThat(underTest.selectDefaultProfile(dbTester.getSession(), "js")).isNull();
}
@Test
public void find_by_language() {
dbTester.prepareDbUnit(getClass(), "select_by_language.xml");
- List<QualityProfileDto> result = underTest.selectByLanguage("java");
+ List<QualityProfileDto> result = underTest.selectByLanguage(dbTester.getSession(), "java");
assertThat(result).hasSize(2);
assertThat(result.get(0).getName()).isEqualTo("Sonar Way 1");
assertThat(result.get(1).getName()).isEqualTo("Sonar Way 2");
public void get_by_id() {
dbTester.prepareDbUnit(getClass(), "shared.xml");
- QualityProfileDto dto = underTest.selectById(1);
+ QualityProfileDto dto = underTest.selectById(dbTester.getSession(), 1);
assertThat(dto.getId()).isEqualTo(1);
assertThat(dto.getName()).isEqualTo("Sonar Way");
assertThat(dto.getLanguage()).isEqualTo("java");
assertThat(dto.getParentKee()).isNull();
- assertThat(underTest.selectById(555)).isNull();
+ assertThat(underTest.selectById(dbTester.getSession(),555)).isNull();
}
@Test
public void select_projects() {
dbTester.prepareDbUnit(getClass(), "projects.xml");
- assertThat(underTest.selectProjects("Sonar Way", "java")).hasSize(2);
+ assertThat(underTest.selectProjects("Sonar Way", "java", dbTester.getSession())).hasSize(2);
}
@Test
public void count_projects_by_profile() {
dbTester.prepareDbUnit(getClass(), "projects.xml");
- assertThat(underTest.countProjectsByProfileKey()).containsOnly(
+ assertThat(underTest.countProjectsByProfileKey(dbTester.getSession())).containsOnly(
MapEntry.entry("java_sonar_way", 2L),
MapEntry.entry("js_sonar_way", 2L));
}
- @Test
- public void select_by_project_id_and_language() {
- dbTester.prepareDbUnit(getClass(), "projects.xml");
-
- QualityProfileDto dto = underTest.selectByProjectAndLanguage(1L, "java");
- assertThat(dto.getId()).isEqualTo(1);
- }
-
@Test
public void select_by_project_key_and_language() {
dbTester.prepareDbUnit(getClass(), "projects.xml");
public void insert() {
dbTester.prepareDbUnit(getClass(), "shared.xml");
- underTest.insert(new FileSourceDto()
+ underTest.insert(session, new FileSourceDto()
.setProjectUuid("PRJ_UUID")
.setFileUuid("FILE2_UUID")
.setBinaryData("FILE2_BINARY_DATA".getBytes())
.setCreatedAt(1500000000000L)
.setUpdatedAt(1500000000001L)
.setRevision("123456789"));
+ session.commit();
dbTester.assertDbUnitTable(getClass(), "insert-result.xml", "file_sources",
"project_uuid", "file_uuid", "data_hash", "line_hashes", "src_hash", "created_at", "updated_at", "data_type", "revision");
public void selectLineHashes_does_not_fail_when_lineshashes_is_null() {
dbTester.prepareDbUnit(getClass(), "shared.xml");
- underTest.insert(new FileSourceDto()
+ underTest.insert(session, new FileSourceDto()
.setProjectUuid("PRJ_UUID")
.setFileUuid("FILE2_UUID")
.setBinaryData("FILE2_BINARY_DATA".getBytes())
.setCreatedAt(1500000000000L)
.setUpdatedAt(1500000000001L)
.setRevision("123456789"));
+ session.commit();
assertThat(underTest.selectLineHashes(dbTester.getSession(), "FILE2_UUID")).isEmpty();
}
public void readLineHashesStream_does_not_fail_when_lineshashes_is_null() {
dbTester.prepareDbUnit(getClass(), "shared.xml");
- underTest.insert(new FileSourceDto()
+ underTest.insert(session, new FileSourceDto()
.setProjectUuid("PRJ_UUID")
.setFileUuid("FILE2_UUID")
.setBinaryData("FILE2_BINARY_DATA".getBytes())
.setCreatedAt(1500000000000L)
.setUpdatedAt(1500000000001L)
.setRevision("123456789"));
+ session.commit();
boolean[] flag = {false};
underTest.readLineHashesStream(dbTester.getSession(), "FILE2_UUID", new Function<Reader, Void>() {
public void update() {
dbTester.prepareDbUnit(getClass(), "shared.xml");
- underTest.update(new FileSourceDto()
+ underTest.update(session, new FileSourceDto()
.setId(101L)
.setProjectUuid("PRJ_UUID")
.setFileUuid("FILE1_UUID")
.setDataType(Type.SOURCE)
.setUpdatedAt(1500000000002L)
.setRevision("987654321"));
+ session.commit();
dbTester.assertDbUnitTable(getClass(), "update-result.xml", "file_sources",
"project_uuid", "file_uuid", "data_hash", "line_hashes", "src_hash", "created_at", "updated_at", "data_type", "revision");
public void selectUserByLogin_ignore_inactive() {
db.prepareDbUnit(getClass(), "selectActiveUserByLogin.xml");
- UserDto user = underTest.selectUserById(50);
+ UserDto user = underTest.selectUserById(session, 50);
assertThat(user.getLogin()).isEqualTo("inactive_user");
- user = underTest.selectActiveUserByLogin("inactive_user");
+ user = underTest.selectActiveUserByLogin(session, "inactive_user");
assertThat(user).isNull();
}
public void selectUserByLogin_not_found() {
db.prepareDbUnit(getClass(), "selectActiveUserByLogin.xml");
- UserDto user = underTest.selectActiveUserByLogin("not_found");
+ UserDto user = underTest.selectActiveUserByLogin(session, "not_found");
assertThat(user).isNull();
}
public void selectUsersByLogins() {
db.prepareDbUnit(getClass(), "selectUsersByLogins.xml");
- Collection<UserDto> users = underTest.selectByLogins(asList("marius", "inactive_user", "other"));
+ Collection<UserDto> users = underTest.selectByLogins(session, asList("marius", "inactive_user", "other"));
assertThat(users).hasSize(2);
assertThat(users).extracting("login").containsOnly("marius", "inactive_user");
}
@Test
public void selectUsersByLogins_empty_logins() {
// no need to access db
- Collection<UserDto> users = underTest.selectByLogins(Collections.<String>emptyList());
+ Collection<UserDto> users = underTest.selectByLogins(session, Collections.emptyList());
assertThat(users).isEmpty();
}
users = underTest.selectByOrderedLogins(session, asList("U2", "U3", "U1"));
assertThat(users).extracting("login").containsExactly("U2", "U1");
- assertThat(underTest.selectByOrderedLogins(session, Collections.<String>emptyList())).isEmpty();
+ assertThat(underTest.selectByOrderedLogins(session, Collections.emptyList())).isEmpty();
}
@Test
db.prepareDbUnit(getClass(), "selectUsersByQuery.xml");
UserQuery query = UserQuery.builder().includeDeactivated().build();
- List<UserDto> users = underTest.selectUsers(query);
+ List<UserDto> users = underTest.selectUsers(session, query);
assertThat(users).hasSize(2);
}
db.prepareDbUnit(getClass(), "selectUsersByQuery.xml");
UserQuery query = UserQuery.ALL_ACTIVES;
- List<UserDto> users = underTest.selectUsers(query);
+ List<UserDto> users = underTest.selectUsers(session, query);
assertThat(users).hasSize(1);
assertThat(users.get(0).getName()).isEqualTo("Marius");
}
db.prepareDbUnit(getClass(), "selectUsersByQuery.xml");
UserQuery query = UserQuery.builder().logins("marius", "john").build();
- List<UserDto> users = underTest.selectUsers(query);
+ List<UserDto> users = underTest.selectUsers(session, query);
assertThat(users).hasSize(1);
assertThat(users.get(0).getName()).isEqualTo("Marius");
}
db.prepareDbUnit(getClass(), "selectUsersByText.xml");
UserQuery query = UserQuery.builder().searchText("sbr").build();
- List<UserDto> users = underTest.selectUsers(query);
+ List<UserDto> users = underTest.selectUsers(session, query);
assertThat(users).hasSize(1);
assertThat(users.get(0).getLogin()).isEqualTo("sbrandhof");
}
db.prepareDbUnit(getClass(), "selectUsersByText.xml");
UserQuery query = UserQuery.builder().searchText("Simon").build();
- List<UserDto> users = underTest.selectUsers(query);
+ List<UserDto> users = underTest.selectUsers(session, query);
assertThat(users).hasSize(1);
assertThat(users.get(0).getLogin()).isEqualTo("sbrandhof");
}
UserQuery query = UserQuery.builder().searchText("%s%").build();
// we expect really a login or name containing the 3 characters "%s%"
- List<UserDto> users = underTest.selectUsers(query);
+ List<UserDto> users = underTest.selectUsers(session, query);
assertThat(users).isEmpty();
}
UserDto user2 = insertUser(true);
UserDto root2 = insertRootUser(newUserDto());
- assertThat(underTest.selectUsers(UserQuery.builder().build()))
+ assertThat(underTest.selectUsers(session, UserQuery.builder().build()))
.extracting(UserDto::getLogin)
.containsOnly(user1.getLogin(), user2.getLogin(), root1.getLogin(), root2.getLogin());
- assertThat(underTest.selectUsers(UserQuery.builder().mustBeRoot().build()))
+ assertThat(underTest.selectUsers(session, UserQuery.builder().mustBeRoot().build()))
.extracting(UserDto::getLogin)
.containsOnly(root1.getLogin(), root2.getLogin());
- assertThat(underTest.selectUsers(UserQuery.builder().mustNotBeRoot().build()))
+ assertThat(underTest.selectUsers(session, UserQuery.builder().mustNotBeRoot().build()))
.extracting(UserDto::getLogin)
.containsOnly(user1.getLogin(), user2.getLogin());
}
underTest.insert(db.getSession(), userDto);
db.getSession().commit();
- UserDto user = underTest.selectActiveUserByLogin("john");
+ UserDto user = underTest.selectActiveUserByLogin(session, "john");
assertThat(user).isNotNull();
assertThat(user.getId()).isNotNull();
assertThat(user.getLogin()).isEqualTo("john");
String login = "does_not_exist";
boolean deactivated = underTest.deactivateUserByLogin(session, login);
assertThat(deactivated).isFalse();
- assertThat(underTest.selectActiveUserByLogin(login)).isNull();
+ assertThat(underTest.selectActiveUserByLogin(session, login)).isNull();
}
@Test
userSession.checkComponentPermission(UserRole.ADMIN, component);
checkIsProjectOrModule(component);
checkProjectOrModuleKeyFormat(newKey);
- dbClient.componentKeyUpdaterDao().updateKey(component.uuid(), newKey);
+ dbClient.componentKeyUpdaterDao().updateKey(dbSession, component.uuid(), newKey);
dbSession.commit();
index(component.uuid());
}
import org.sonar.api.measures.CoreMetrics;
import org.sonar.core.issue.DefaultIssue;
import org.sonar.db.DbClient;
+import org.sonar.db.DbSession;
import org.sonar.db.issue.IssueChangeDto;
import org.sonar.server.computation.task.projectanalysis.component.Component;
import org.sonar.server.computation.task.projectanalysis.measure.Measure;
private NewEffortCounter counter = null;
public NewEffortAggregator(NewEffortCalculator calculator, PeriodHolder periodHolder, DbClient dbClient,
- MetricRepository metricRepository, MeasureRepository measureRepository) {
+ MetricRepository metricRepository, MeasureRepository measureRepository) {
this.calculator = calculator;
this.periodHolder = periodHolder;
this.dbClient = dbClient;
@Override
public void beforeComponent(Component component) {
- List<IssueChangeDto> changes = dbClient.issueChangeDao().selectChangelogOfNonClosedIssuesByComponent(component.getUuid());
- for (IssueChangeDto change : changes) {
- changesByIssueUuid.put(change.getIssueKey(), change);
+ try (DbSession dbSession = dbClient.openSession(false)) {
+ List<IssueChangeDto> changes = dbClient.issueChangeDao().selectChangelogOfNonClosedIssuesByComponent(dbSession, component.getUuid());
+ for (IssueChangeDto change : changes) {
+ changesByIssueUuid.put(change.getIssueKey(), change);
+ }
}
counter = new NewEffortCounter(calculator);
*/
package org.sonar.server.computation.task.projectanalysis.qualitygate;
-import com.google.common.base.Function;
import com.google.common.base.Optional;
-import org.sonar.db.qualitygate.QualityGateConditionDao;
+import java.util.Collection;
+import org.sonar.core.util.stream.Collectors;
+import org.sonar.db.DbClient;
+import org.sonar.db.DbSession;
import org.sonar.db.qualitygate.QualityGateConditionDto;
-import org.sonar.db.qualitygate.QualityGateDao;
import org.sonar.db.qualitygate.QualityGateDto;
import org.sonar.server.computation.task.projectanalysis.metric.Metric;
import org.sonar.server.computation.task.projectanalysis.metric.MetricRepository;
-import static com.google.common.collect.FluentIterable.from;
-
public class QualityGateServiceImpl implements QualityGateService {
- private final QualityGateDao qualityGateDao;
- private final QualityGateConditionDao conditionDao;
- private final Function<QualityGateConditionDto, Condition> conditionDtoToBean;
-
- public QualityGateServiceImpl(QualityGateDao qualityGateDao, QualityGateConditionDao conditionDao, final MetricRepository metricRepository) {
- this.qualityGateDao = qualityGateDao;
- this.conditionDao = conditionDao;
- this.conditionDtoToBean = (QualityGateConditionDto input) -> {
- Metric metric = metricRepository.getById(input.getMetricId());
- return new Condition(metric, input.getOperator(), input.getErrorThreshold(), input.getWarningThreshold(), input.getPeriod() != null);
- };
+
+ private final DbClient dbClient;
+ private final MetricRepository metricRepository;
+
+ public QualityGateServiceImpl(DbClient dbClient, final MetricRepository metricRepository) {
+ this.dbClient = dbClient;
+ this.metricRepository = metricRepository;
}
@Override
public Optional<QualityGate> findById(long id) {
- QualityGateDto qualityGateDto = qualityGateDao.selectById(id);
- if (qualityGateDto == null) {
- return Optional.absent();
+ try (DbSession dbSession = dbClient.openSession(false)) {
+ QualityGateDto qualityGateDto = dbClient.qualityGateDao().selectById(dbSession, id);
+ if (qualityGateDto == null) {
+ return Optional.absent();
+ }
+ return Optional.of(toQualityGate(dbSession, qualityGateDto));
}
- return Optional.of(toQualityGate(qualityGateDto));
}
- private QualityGate toQualityGate(QualityGateDto qualityGateDto) {
- Iterable<Condition> conditions = from(conditionDao.selectForQualityGate(qualityGateDto.getId())).transform(conditionDtoToBean);
+ private QualityGate toQualityGate(DbSession dbSession, QualityGateDto qualityGateDto) {
+ Collection<QualityGateConditionDto> dtos = dbClient.gateConditionDao().selectForQualityGate(dbSession, qualityGateDto.getId());
+
+ Iterable<Condition> conditions = dtos.stream()
+ .map(input -> {
+ Metric metric = metricRepository.getById(input.getMetricId());
+ return new Condition(metric, input.getOperator(), input.getErrorThreshold(), input.getWarningThreshold(), input.getPeriod() != null);
+ })
+ .collect(Collectors.toList(dtos.size()));
return new QualityGate(qualityGateDto.getId(), qualityGateDto.getName(), conditions);
}
import java.util.Optional;
import org.sonar.api.server.ServerSide;
import org.sonar.api.utils.log.Loggers;
+import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
-import org.sonar.db.MyBatis;
import org.sonar.db.version.SqTables;
import org.sonar.server.component.index.ComponentIndexDefinition;
import org.sonar.server.es.BulkIndexer;
"schema_migrations", BackendCleanup::truncateSchemaMigrations);
private final EsClient esClient;
- private final MyBatis myBatis;
+ private final DbClient dbClient;
- public BackendCleanup(EsClient esClient, MyBatis myBatis) {
+ public BackendCleanup(EsClient esClient, DbClient dbClient) {
this.esClient = esClient;
- this.myBatis = myBatis;
+ this.dbClient = dbClient;
}
public void clearAll() {
}
public void clearDb() {
- try (DbSession dbSession = myBatis.openSession(false);
+ try (DbSession dbSession = dbClient.openSession(false);
Connection connection = dbSession.getConnection();
Statement ddlStatement = connection.createStatement()) {
for (String tableName : SqTables.TABLES) {
* Please be careful when updating this method as it's called by Orchestrator.
*/
public void resetData() {
- try (DbSession dbSession = myBatis.openSession(false);
+ try (DbSession dbSession = dbClient.openSession(false);
Connection connection = dbSession.getConnection()) {
truncateAnalysisTables(connection);
import org.sonar.server.qualityprofile.QProfileProjectOperations;
import org.sonar.server.qualityprofile.QProfileReset;
import org.sonar.server.qualityprofile.QProfileService;
-import org.sonar.server.qualityprofile.QProfiles;
import org.sonar.server.qualityprofile.RuleActivator;
import org.sonar.server.qualityprofile.RuleActivatorContextFactory;
import org.sonar.server.qualityprofile.index.ActiveRuleIndexer;
XMLProfileParser.class,
XMLProfileSerializer.class,
AnnotationProfileParser.class,
- QProfiles.class,
QProfileLookup.class,
QProfileProjectOperations.class,
QProfileComparison.class,
}
private Collection<QualityGateConditionDto> getConditions(DbSession dbSession, long qGateId, @Nullable Long conditionId) {
- Collection<QualityGateConditionDto> conditions = dbClient.gateConditionDao().selectForQualityGate(qGateId, dbSession);
+ Collection<QualityGateConditionDto> conditions = dbClient.gateConditionDao().selectForQualityGate(dbSession, qGateId);
if (conditionId == null) {
return conditions;
}
- return dbClient.gateConditionDao().selectForQualityGate(qGateId, dbSession).stream()
+ return dbClient.gateConditionDao().selectForQualityGate(dbSession, qGateId).stream()
.filter(condition -> condition.getId() != conditionId)
.collect(Collectors.toList());
}
}
public QualityGateDto create(DbSession dbSession, String name) {
- validateQualityGate(null, name);
+ validateQualityGate(dbSession, null, name);
QualityGateDto newQualityGate = new QualityGateDto().setName(name);
dbClient.qualityGateDao().insert(dbSession, newQualityGate);
return newQualityGate;
}
- private void validateQualityGate(@Nullable Long qGateId, @Nullable String name) {
+ private void validateQualityGate(DbSession dbSession, @Nullable Long qGateId, @Nullable String name) {
Errors errors = new Errors();
if (isNullOrEmpty(name)) {
errors.add(Message.of(Validation.CANT_BE_EMPTY_MESSAGE, "Name"));
} else {
- checkQualityGateDoesNotAlreadyExist(qGateId, name, errors);
+ checkQualityGateDoesNotAlreadyExist(dbSession, qGateId, name, errors);
}
if (!errors.isEmpty()) {
throw BadRequestException.create(errors);
}
}
- private void checkQualityGateDoesNotAlreadyExist(@Nullable Long qGateId, String name, Errors errors) {
- QualityGateDto existingQgate = dbClient.qualityGateDao().selectByName(name);
+ private void checkQualityGateDoesNotAlreadyExist(DbSession dbSession, @Nullable Long qGateId, String name, Errors errors) {
+ QualityGateDto existingQgate = dbClient.qualityGateDao().selectByName(dbSession, name);
boolean isModifyingCurrentQgate = qGateId != null && existingQgate != null && existingQgate.getId().equals(qGateId);
errors.check(isModifyingCurrentQgate || existingQgate == null, Validation.IS_ALREADY_USED_MESSAGE, "Name");
}
import org.sonar.api.web.UserRole;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
-import org.sonar.db.MyBatis;
import org.sonar.db.component.ComponentDto;
import org.sonar.db.permission.OrganizationPermission;
import org.sonar.db.property.PropertiesDao;
public QualityGateDto rename(long idToRename, String name) {
checkIsSystemAdministrator();
- QualityGateDto toRename = getNonNullQgate(idToRename);
- validateQualityGate(idToRename, name);
- toRename.setName(name);
- dao.update(toRename);
- return toRename;
+ try (DbSession dbSession = dbClient.openSession(false)) {
+ QualityGateDto toRename = getNonNullQgate(idToRename);
+ validateQualityGate(dbSession, idToRename, name);
+ toRename.setName(name);
+ dao.update(toRename, dbSession);
+ dbSession.commit();
+ return toRename;
+ }
}
public QualityGateDto copy(long sourceId, String destinationName) {
checkIsSystemAdministrator();
getNonNullQgate(sourceId);
- validateQualityGate(null, destinationName);
- QualityGateDto destinationGate = new QualityGateDto().setName(destinationName);
- DbSession dbSession = dbClient.openSession(false);
- try {
+ try (DbSession dbSession = dbClient.openSession(false)) {
+ validateQualityGate(dbSession, null, destinationName);
+ QualityGateDto destinationGate = new QualityGateDto().setName(destinationName);
dao.insert(dbSession, destinationGate);
- for (QualityGateConditionDto sourceCondition : conditionDao.selectForQualityGate(sourceId, dbSession)) {
+ for (QualityGateConditionDto sourceCondition : conditionDao.selectForQualityGate(dbSession, sourceId)) {
conditionDao.insert(new QualityGateConditionDto().setQualityGateId(destinationGate.getId())
.setMetricId(sourceCondition.getMetricId()).setOperator(sourceCondition.getOperator())
.setWarningThreshold(sourceCondition.getWarningThreshold()).setErrorThreshold(sourceCondition.getErrorThreshold()).setPeriod(sourceCondition.getPeriod()),
dbSession);
}
dbSession.commit();
- } finally {
- MyBatis.closeQuietly(dbSession);
+ return destinationGate;
}
- return destinationGate;
}
public Collection<QualityGateDto> list() {
- return dao.selectAll();
+ try (DbSession dbSession = dbClient.openSession(false)) {
+ return dao.selectAll(dbSession);
+ }
}
public void delete(long idToDelete) {
checkIsSystemAdministrator();
QualityGateDto qGate = getNonNullQgate(idToDelete);
- DbSession session = dbClient.openSession(false);
- try {
+ try (DbSession session = dbClient.openSession(false)) {
if (isDefault(qGate)) {
propertiesDao.deleteGlobalProperty(SONAR_QUALITYGATE_PROPERTY, session);
}
propertiesDao.deleteProjectProperties(SONAR_QUALITYGATE_PROPERTY, Long.toString(idToDelete), session);
dao.delete(qGate, session);
session.commit();
- } finally {
- MyBatis.closeQuietly(session);
}
}
Long defaultId = getDefaultId();
if (defaultId == null) {
return null;
- } else {
- return dao.selectById(defaultId);
+ }
+ try (DbSession dbSession = dbClient.openSession(false)) {
+ return dao.selectById(dbSession, defaultId);
}
}
public Collection<QualityGateConditionDto> listConditions(long qGateId) {
- Collection<QualityGateConditionDto> conditionsForGate = conditionDao.selectForQualityGate(qGateId);
- for (QualityGateConditionDto condition : conditionsForGate) {
- Metric metric = metricFinder.findById((int) condition.getMetricId());
- if (metric == null) {
- throw new IllegalStateException("Could not find metric with id " + condition.getMetricId());
+ try (DbSession dbSession = dbClient.openSession(false)) {
+ Collection<QualityGateConditionDto> conditionsForGate = conditionDao.selectForQualityGate(dbSession, qGateId);
+ for (QualityGateConditionDto condition : conditionsForGate) {
+ Metric metric = metricFinder.findById((int) condition.getMetricId());
+ if (metric == null) {
+ throw new IllegalStateException("Could not find metric with id " + condition.getMetricId());
+ }
+ condition.setMetricKey(metric.getKey());
}
- condition.setMetricKey(metric.getKey());
+ return conditionsForGate;
}
- return conditionsForGate;
}
public void deleteCondition(Long condId) {
checkIsSystemAdministrator();
- conditionDao.delete(getNonNullCondition(condId));
+ try (DbSession dbSession = dbClient.openSession(false)) {
+ conditionDao.delete(getNonNullCondition(dbSession, condId), dbSession);
+ dbSession.commit();
+ }
}
public void dissociateProject(DbSession dbSession, Long qGateId, ComponentDto project) {
}
private QualityGateDto getNonNullQgate(String name) {
- QualityGateDto qGate = dao.selectByName(name);
- if (qGate == null) {
- throw new NotFoundException("There is no quality gate with name=" + name);
+ try (DbSession dbSession = dbClient.openSession(false)) {
+ QualityGateDto qGate = dao.selectByName(dbSession, name);
+ if (qGate == null) {
+ throw new NotFoundException("There is no quality gate with name=" + name);
+ }
+ return qGate;
}
- return qGate;
}
- private QualityGateConditionDto getNonNullCondition(long id) {
- QualityGateConditionDto condition = conditionDao.selectById(id);
+ private QualityGateConditionDto getNonNullCondition(DbSession dbSession, long id) {
+ QualityGateConditionDto condition = conditionDao.selectById(id, dbSession);
if (condition == null) {
throw new NotFoundException("There is no condition with id=" + id);
}
return condition;
}
- private void validateQualityGate(@Nullable Long updatingQgateId, @Nullable String name) {
+ private void validateQualityGate(DbSession dbSession, @Nullable Long updatingQgateId, @Nullable String name) {
Errors errors = new Errors();
if (Strings.isNullOrEmpty(name)) {
errors.add(Message.of(Validation.CANT_BE_EMPTY_MESSAGE, "Name"));
} else {
- checkQgateNotAlreadyExists(updatingQgateId, name, errors);
+ checkQgateNotAlreadyExists(dbSession, updatingQgateId, name, errors);
}
if (!errors.isEmpty()) {
throw BadRequestException.create(errors);
}
}
- private void checkQgateNotAlreadyExists(@Nullable Long updatingQgateId, String name, Errors errors) {
- QualityGateDto existingQgate = dao.selectByName(name);
+ private void checkQgateNotAlreadyExists(DbSession dbSession, @Nullable Long updatingQgateId, String name, Errors errors) {
+ QualityGateDto existingQgate = dao.selectByName(dbSession, name);
boolean isModifyingCurrentQgate = updatingQgateId != null && existingQgate != null && existingQgate.getId().equals(updatingQgateId);
errors.check(isModifyingCurrentQgate || existingQgate == null, Validation.IS_ALREADY_USED_MESSAGE, "Name");
}
private void doHandle(SelectWsRequest request) {
try (DbSession dbSession = dbClient.openSession(false)) {
- checkQualityGate(dbClient, request.getGateId());
+ checkQualityGate(dbSession, request.getGateId());
ComponentDto project = getProject(dbSession, request.getProjectId(), request.getProjectKey());
dbClient.propertiesDao().saveProperty(dbSession, new PropertyDto()
}
}
- private static void checkQualityGate(DbClient dbClient, long id) {
- checkFound(dbClient.qualityGateDao().selectById(id), "There is no quality gate with id=" + id);
+ private void checkQualityGate(DbSession dbSession, long id) {
+ checkFound(dbClient.qualityGateDao().selectById(dbSession, id), "There is no quality gate with id=" + id);
}
}
import java.util.List;
import javax.annotation.CheckForNull;
import javax.annotation.Nonnull;
-import org.sonar.api.ce.ComputeEngineSide;
import org.sonar.api.server.ServerSide;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import static com.google.common.collect.Lists.newArrayList;
@ServerSide
-@ComputeEngineSide
public class QProfileLookup {
private final DbClient db;
this.db = db;
}
- public List<QProfile> allProfiles() {
- return toQProfiles(db.qualityProfileDao().selectAll());
+ public List<QProfile> allProfiles(DbSession dbSession) {
+ return toQProfiles(db.qualityProfileDao().selectAll(dbSession));
}
- public List<QProfile> profiles(String language) {
- return toQProfiles(db.qualityProfileDao().selectByLanguage(language));
- }
-
- @CheckForNull
- public QProfile profile(int id) {
- DbSession session = db.openSession(false);
- try {
- return profile(id, session);
- } finally {
- session.close();
- }
- }
-
- @CheckForNull
- public QProfile profile(int id, DbSession session) {
- QualityProfileDto dto = findQualityProfile(id, session);
- if (dto != null) {
- return QProfile.from(dto);
- }
- return null;
- }
-
- public QProfile profile(String name, String language, DbSession session) {
- QualityProfileDto dto = findQualityProfile(name, language, session);
- if (dto != null) {
- return QProfile.from(dto);
- }
- return null;
+ public List<QProfile> profiles(DbSession dbSession, String language) {
+ return toQProfiles(db.qualityProfileDao().selectByLanguage(dbSession, language));
}
@CheckForNull
public QProfile profile(String name, String language) {
- DbSession session = db.openSession(false);
- try {
- return profile(name, language, session);
- } finally {
- session.close();
- }
- }
-
- @CheckForNull
- public QProfile parent(QProfile profile) {
- DbSession session = db.openSession(false);
- try {
- String parent = profile.parent();
- if (parent != null) {
- QualityProfileDto parentDto = findQualityProfile(parent, profile.language(), session);
- if (parentDto != null) {
- return QProfile.from(parentDto);
- }
+ try (DbSession dbSession = db.openSession(false)) {
+ QualityProfileDto dto = findQualityProfile(name, language, dbSession);
+ if (dto != null) {
+ return QProfile.from(dto);
}
return null;
- } finally {
- session.close();
- }
- }
-
- public List<QProfile> children(QProfile profile) {
- DbSession session = db.openSession(false);
- try {
- return children(profile, session);
- } finally {
- session.close();
}
}
- public List<QProfile> children(QProfile profile, DbSession session) {
- return toQProfiles(db.qualityProfileDao().selectChildren(session, profile.key()));
- }
-
public List<QProfile> ancestors(QualityProfileDto profile, DbSession session) {
List<QProfile> ancestors = newArrayList();
incrementAncestors(QProfile.from(profile), ancestors, session);
return ancestors;
}
- public List<QProfile> ancestors(QProfile profile) {
- List<QProfile> ancestors = newArrayList();
- DbSession session = db.openSession(false);
- try {
- incrementAncestors(profile, ancestors, session);
- } finally {
- session.close();
- }
- return ancestors;
- }
-
private void incrementAncestors(QProfile profile, List<QProfile> ancestors, DbSession session) {
if (profile.parent() != null) {
QualityProfileDto parentDto = db.qualityProfileDao().selectParentById(session, profile.id());
return newArrayList(Iterables.transform(dtos, ToQProfile.INSTANCE));
}
- @CheckForNull
- private QualityProfileDto findQualityProfile(int id, DbSession session) {
- return db.qualityProfileDao().selectById(session, id);
- }
-
@CheckForNull
private QualityProfileDto findQualityProfile(String name, String language, DbSession session) {
return db.qualityProfileDao().selectByNameAndLanguage(name, language, session);
+++ /dev/null
-/*
- * SonarQube
- * Copyright (C) 2009-2017 SonarSource SA
- * mailto:info AT sonarsource DOT com
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 3 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-package org.sonar.server.qualityprofile;
-
-import java.util.List;
-import javax.annotation.CheckForNull;
-import org.sonar.api.server.ServerSide;
-import org.sonar.db.DbClient;
-import org.sonar.db.qualityprofile.QualityProfileDto;
-
-/**
- * Use {@link org.sonar.server.qualityprofile.QProfileService} instead
- */
-@Deprecated
-@ServerSide
-public class QProfiles {
-
- private final QProfileLookup profileLookup;
- private final DbClient dbClient;
-
- public QProfiles(QProfileLookup profileLookup, DbClient dbClient) {
- this.profileLookup = profileLookup;
- this.dbClient = dbClient;
- }
-
- public List<QProfile> allProfiles() {
- return profileLookup.allProfiles();
- }
-
- public List<QProfile> profilesByLanguage(String language) {
- return profileLookup.profiles(language);
- }
-
- /**
- * Used in /project/profile and in /api/profiles
- */
- @CheckForNull
- public QProfile findProfileByProjectAndLanguage(long projectId, String language) {
- QualityProfileDto dto = dbClient.qualityProfileDao().selectByProjectAndLanguage(projectId, language);
- if (dto != null) {
- return QProfile.from(dto);
- }
- return null;
- }
-
-}
SearchData load(SearchWsRequest request) {
validateRequest(request);
- return new SearchData()
- .setProfiles(findProfiles(request))
- .setActiveRuleCountByProfileKey(activeRuleIndex.countAllByQualityProfileKey())
- .setActiveDeprecatedRuleCountByProfileKey(activeRuleIndex.countAllDeprecatedByQualityProfileKey())
- .setProjectCountByProfileKey(dbClient.qualityProfileDao().countProjectsByProfileKey());
+ try (DbSession dbSession = dbClient.openSession(false)) {
+ return new SearchData()
+ .setProfiles(findProfiles(dbSession, request))
+ .setActiveRuleCountByProfileKey(activeRuleIndex.countAllByQualityProfileKey())
+ .setActiveDeprecatedRuleCountByProfileKey(activeRuleIndex.countAllDeprecatedByQualityProfileKey())
+ .setProjectCountByProfileKey(dbClient.qualityProfileDao().countProjectsByProfileKey(dbSession));
+ }
}
- private List<QProfile> findProfiles(SearchWsRequest request) {
+ private List<QProfile> findProfiles(DbSession dbSession, SearchWsRequest request) {
Collection<QProfile> profiles;
if (askDefaultProfiles(request)) {
- profiles = findDefaultProfiles(request);
+ profiles = findDefaultProfiles(dbSession, request);
} else if (hasComponentKey(request)) {
- profiles = findProjectProfiles(request);
+ profiles = findProjectProfiles(dbSession, request);
} else {
- profiles = findAllProfiles(request);
+ profiles = findAllProfiles(dbSession, request);
}
return profiles.stream().sorted(QProfileComparator.INSTANCE).collect(Collectors.toList());
}
- private Collection<QProfile> findDefaultProfiles(SearchWsRequest request) {
+ private Collection<QProfile> findDefaultProfiles(DbSession dbSession, SearchWsRequest request) {
String profileName = request.getProfileName();
Set<String> languageKeys = getLanguageKeys();
- try (DbSession dbSession = dbClient.openSession(false)) {
- Map<String, QProfile> qualityProfiles = new HashMap<>(languageKeys.size());
-
- Set<String> missingLanguageKeys = lookupByProfileName(dbSession, qualityProfiles, languageKeys, profileName);
- Set<String> noDefaultProfileLanguageKeys = lookupDefaults(dbSession, qualityProfiles, missingLanguageKeys);
+ Map<String, QProfile> qualityProfiles = new HashMap<>(languageKeys.size());
- if (!noDefaultProfileLanguageKeys.isEmpty()) {
- throw new IllegalStateException(format("No quality profile can been found on language(s) '%s'", noDefaultProfileLanguageKeys));
- }
+ Set<String> missingLanguageKeys = lookupByProfileName(dbSession, qualityProfiles, languageKeys, profileName);
+ Set<String> noDefaultProfileLanguageKeys = lookupDefaults(dbSession, qualityProfiles, missingLanguageKeys);
- return qualityProfiles.values();
+ if (!noDefaultProfileLanguageKeys.isEmpty()) {
+ throw new IllegalStateException(format("No quality profile can been found on language(s) '%s'", noDefaultProfileLanguageKeys));
}
+
+ return qualityProfiles.values();
}
- private Collection<QProfile> findProjectProfiles(SearchWsRequest request) {
+ private Collection<QProfile> findProjectProfiles(DbSession dbSession, SearchWsRequest request) {
String componentKey = request.getProjectKey();
String profileName = request.getProfileName();
Set<String> languageKeys = getLanguageKeys();
- try (DbSession dbSession = dbClient.openSession(false)) {
- Map<String, QProfile> qualityProfiles = new HashMap<>(languageKeys.size());
+ Map<String, QProfile> qualityProfiles = new HashMap<>(languageKeys.size());
- // look up profiles by profileName (if any) for each language
- Set<String> unresolvedLanguages = lookupByProfileName(dbSession, qualityProfiles, languageKeys, profileName);
- // look up profile by componentKey for each language for which we don't have one yet
- Set<String> stillUnresolvedLanguages = lookupByModuleKey(dbSession, qualityProfiles, unresolvedLanguages, componentKey);
- // look up profile by default for each language for which we don't have one yet
- Set<String> noDefaultProfileLanguages = lookupDefaults(dbSession, qualityProfiles, stillUnresolvedLanguages);
+ // look up profiles by profileName (if any) for each language
+ Set<String> unresolvedLanguages = lookupByProfileName(dbSession, qualityProfiles, languageKeys, profileName);
+ // look up profile by componentKey for each language for which we don't have one yet
+ Set<String> stillUnresolvedLanguages = lookupByModuleKey(dbSession, qualityProfiles, unresolvedLanguages, componentKey);
+ // look up profile by default for each language for which we don't have one yet
+ Set<String> noDefaultProfileLanguages = lookupDefaults(dbSession, qualityProfiles, stillUnresolvedLanguages);
- if (!noDefaultProfileLanguages.isEmpty()) {
- throw new IllegalStateException(format("No quality profile can been found on language(s) '%s' for project '%s'", noDefaultProfileLanguages, componentKey));
- }
-
- return qualityProfiles.values();
+ if (!noDefaultProfileLanguages.isEmpty()) {
+ throw new IllegalStateException(format("No quality profile can been found on language(s) '%s' for project '%s'", noDefaultProfileLanguages, componentKey));
}
+
+ return qualityProfiles.values();
}
- private List<QProfile> findAllProfiles(SearchWsRequest request) {
+ private List<QProfile> findAllProfiles(DbSession dbSession, SearchWsRequest request) {
String language = request.getLanguage();
if (language == null) {
- return profileLookup.allProfiles().stream().filter(qProfile -> languages.get(qProfile.language()) != null).collect(Collectors.toList());
+ return profileLookup.allProfiles(dbSession).stream().filter(qProfile -> languages.get(qProfile.language()) != null).collect(Collectors.toList());
}
- return profileLookup.profiles(language);
+ return profileLookup.profiles(dbSession, language);
}
private Set<String> lookupByProfileName(DbSession dbSession, Map<String, QProfile> qualityProfiles, Set<String> languageKeys, @Nullable String profileName) {
import org.sonar.api.user.User;
import org.sonar.api.user.UserFinder;
import org.sonar.api.user.UserQuery;
-import org.sonar.db.user.UserDao;
+import org.sonar.db.DbClient;
+import org.sonar.db.DbSession;
import org.sonar.db.user.UserDto;
/**
*/
public class DefaultUserFinder implements UserFinder {
- private final UserDao userDao;
+ private final DbClient dbClient;
- public DefaultUserFinder(UserDao userDao) {
- this.userDao = userDao;
+ public DefaultUserFinder(DbClient dbClient) {
+ this.dbClient = dbClient;
}
@Override
@CheckForNull
public User findByLogin(String login) {
- UserDto dto = userDao.selectActiveUserByLogin(login);
- return dto != null ? dto.toUser() : null;
+ try (DbSession dbSession = dbClient.openSession(false)) {
+ UserDto dto = dbClient.userDao().selectActiveUserByLogin(dbSession, login);
+ return dto != null ? dto.toUser() : null;
+ }
}
@Override
public List<User> findByLogins(List<String> logins) {
- List<UserDto> dtos = userDao.selectByLogins(logins);
- return toUsers(dtos);
+ try (DbSession dbSession = dbClient.openSession(false)) {
+ List<UserDto> dtos = dbClient.userDao().selectByLogins(dbSession, logins);
+ return toUsers(dtos);
+ }
}
@Override
public List<User> find(UserQuery query) {
- List<UserDto> dtos = userDao.selectUsers(query);
- return toUsers(dtos);
+ try (DbSession dbSession = dbClient.openSession(false)) {
+ List<UserDto> dtos = dbClient.userDao().selectUsers(dbSession, query);
+ return toUsers(dtos);
+ }
}
private static List<User> toUsers(Collection<UserDto> dtos) {
import javax.annotation.Nullable;
import org.sonar.api.database.model.User;
import org.sonar.api.security.UserFinder;
-import org.sonar.db.user.UserDao;
+import org.sonar.db.DbClient;
+import org.sonar.db.DbSession;
import org.sonar.db.user.UserDto;
/**
*/
public class DeprecatedUserFinder implements UserFinder {
- private final UserDao userDao;
+ private final DbClient dbClient;
- public DeprecatedUserFinder(UserDao userDao) {
- this.userDao = userDao;
+ public DeprecatedUserFinder(DbClient dbClient) {
+ this.dbClient = dbClient;
}
@Override
public User findById(int id) {
- return copy(userDao.selectUserById(id));
+ try (DbSession dbSession = dbClient.openSession(false)) {
+ return copy(dbClient.userDao().selectUserById(dbSession, id));
+ }
}
@Override
public User findByLogin(String login) {
- return copy(userDao.selectActiveUserByLogin(login));
+ try (DbSession dbSession = dbClient.openSession(false)) {
+ return copy(dbClient.userDao().selectActiveUserByLogin(dbSession, login));
+ }
}
private static User copy(@Nullable UserDto dto) {
ComponentDto file = ComponentTesting.newFileDto(project, null, "file");
dbClient.componentDao().insert(dbSession, file);
- tester.get(FileSourceDao.class).insert(newFileSourceDto(file).setSrcHash("123456"));
-
+ tester.get(FileSourceDao.class).insert(dbSession, newFileSourceDto(file).setSrcHash("123456"));
dbSession.commit();
ProjectRepositories ref = underTest.load(ProjectDataQuery.create().setModuleKey(project.key()));
// File on project
ComponentDto projectFile = ComponentTesting.newFileDto(project, null, "projectFile");
dbClient.componentDao().insert(dbSession, projectFile);
- tester.get(FileSourceDao.class).insert(newFileSourceDto(projectFile).setSrcHash("123456"));
+ tester.get(FileSourceDao.class).insert(dbSession, newFileSourceDto(projectFile).setSrcHash("123456"));
ComponentDto module = ComponentTesting.newModuleDto(project);
dbClient.componentDao().insert(dbSession, module);
// File on module
ComponentDto moduleFile = ComponentTesting.newFileDto(module, null, "moduleFile");
dbClient.componentDao().insert(dbSession, moduleFile);
- tester.get(FileSourceDao.class).insert(newFileSourceDto(moduleFile).setSrcHash("789456"));
+ tester.get(FileSourceDao.class).insert(dbSession, newFileSourceDto(moduleFile).setSrcHash("789456"));
dbSession.commit();
// File on project
ComponentDto projectFile = ComponentTesting.newFileDto(project, null, "projectFile");
dbClient.componentDao().insert(dbSession, projectFile);
- tester.get(FileSourceDao.class).insert(newFileSourceDto(projectFile).setSrcHash("123456").setRevision("987654321"));
+ tester.get(FileSourceDao.class).insert(dbSession, newFileSourceDto(projectFile).setSrcHash("123456").setRevision("987654321"));
ComponentDto module = ComponentTesting.newModuleDto(project);
userSessionRule.logIn().addProjectUuidPermissions(SCAN_EXECUTION, project.uuid());
// File on module
ComponentDto moduleFile = ComponentTesting.newFileDto(module, null, "moduleFile");
dbClient.componentDao().insert(dbSession, moduleFile);
- tester.get(FileSourceDao.class).insert(newFileSourceDto(moduleFile).setSrcHash("789456").setRevision("123456789"));
+ tester.get(FileSourceDao.class).insert(dbSession, newFileSourceDto(moduleFile).setSrcHash("789456").setRevision("123456789"));
dbSession.commit();
import com.google.common.base.Optional;
import com.google.common.collect.ImmutableList;
import java.util.Collections;
+import org.junit.Before;
import org.junit.Test;
+import org.sonar.db.DbClient;
+import org.sonar.db.DbSession;
import org.sonar.db.qualitygate.QualityGateConditionDao;
import org.sonar.db.qualitygate.QualityGateConditionDto;
import org.sonar.db.qualitygate.QualityGateDao;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.guava.api.Assertions.assertThat;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
private QualityGateDao qualityGateDao = mock(QualityGateDao.class);
private QualityGateConditionDao qualityGateConditionDao = mock(QualityGateConditionDao.class);
private MetricRepository metricRepository = mock(MetricRepository.class);
- private QualityGateServiceImpl underTest = new QualityGateServiceImpl(qualityGateDao, qualityGateConditionDao, metricRepository);
+ private DbClient dbClient = mock(DbClient.class);
+ private QualityGateServiceImpl underTest = new QualityGateServiceImpl(dbClient, metricRepository);
+
+ @Before
+ public void setUp() throws Exception {
+ when(dbClient.qualityGateDao()).thenReturn(qualityGateDao);
+ when(dbClient.gateConditionDao()).thenReturn(qualityGateConditionDao);
+ }
@Test
public void findById_returns_absent_when_QualityGateDto_does_not_exist() {
@Test
public void findById_returns_QualityGate_with_empty_set_of_conditions_when_there_is_none_in_DB() {
- when(qualityGateDao.selectById(SOME_ID)).thenReturn(QUALITY_GATE_DTO);
- when(qualityGateConditionDao.selectForQualityGate(SOME_ID)).thenReturn(Collections.<QualityGateConditionDto>emptyList());
+ when(qualityGateDao.selectById(any(DbSession.class), eq(SOME_ID))).thenReturn(QUALITY_GATE_DTO);
+ when(qualityGateConditionDao.selectForQualityGate(any(DbSession.class), eq(SOME_ID))).thenReturn(Collections.emptyList());
Optional<QualityGate> res = underTest.findById(SOME_ID);
@Test
public void findById_returns_conditions_when_there_is_some_in_DB() {
- when(qualityGateDao.selectById(SOME_ID)).thenReturn(QUALITY_GATE_DTO);
- when(qualityGateConditionDao.selectForQualityGate(SOME_ID)).thenReturn(ImmutableList.of(CONDITION_1, CONDITION_2));
+ when(qualityGateDao.selectById(any(DbSession.class), eq(SOME_ID))).thenReturn(QUALITY_GATE_DTO);
+ when(qualityGateConditionDao.selectForQualityGate(any(DbSession.class), eq(SOME_ID))).thenReturn(ImmutableList.of(CONDITION_1, CONDITION_2));
// metrics are always supposed to be there
when(metricRepository.getById(METRIC_ID_1)).thenReturn(METRIC_1);
when(metricRepository.getById(METRIC_ID_2)).thenReturn(METRIC_2);
if (revision != null) {
builder.setScmRevision(revision);
}
- dbTester.getDbClient().fileSourceDao().insert(new FileSourceDto()
+ dbTester.getDbClient().fileSourceDao().insert(dbTester.getSession(), new FileSourceDto()
.setFileUuid(FILE.getUuid())
.setProjectUuid("PROJECT_UUID")
.setSourceData(fileDataBuilder.build())
.setSrcHash(srcHash));
+ dbTester.commit();
}
private void addCopyFromPreviousChangesetInReport() {
public void no_test_in_database_and_batch_report() {
underTest.execute();
- assertThat(dbClient.fileSourceDao().selectTest(TEST_FILE_UUID_1)).isNull();
+ assertThat(dbClient.fileSourceDao().selectTest(db.getSession(), TEST_FILE_UUID_1)).isNull();
assertThat(log.logs()).isEmpty();
}
assertThat(db.countRowsOfTable("file_sources")).isEqualTo(1);
- FileSourceDto dto = dbClient.fileSourceDao().selectTest(TEST_FILE_UUID_1);
+ FileSourceDto dto = dbClient.fileSourceDao().selectTest(db.getSession(), TEST_FILE_UUID_1);
assertThat(dto.getCreatedAt()).isEqualTo(now);
assertThat(dto.getUpdatedAt()).isEqualTo(now);
assertThat(dto.getProjectUuid()).isEqualTo(PROJECT_UUID);
underTest.execute();
- FileSourceDto dto = dbClient.fileSourceDao().selectTest(TEST_FILE_UUID_1);
+ FileSourceDto dto = dbClient.fileSourceDao().selectTest(db.getSession(), TEST_FILE_UUID_1);
assertThat(dto.getCreatedAt()).isEqualTo(now);
assertThat(dto.getUpdatedAt()).isEqualTo(now);
assertThat(dto.getProjectUuid()).isEqualTo(PROJECT_UUID);
underTest.execute();
- FileSourceDto dto = dbClient.fileSourceDao().selectTest(TEST_FILE_UUID_1);
+ FileSourceDto dto = dbClient.fileSourceDao().selectTest(db.getSession(), TEST_FILE_UUID_1);
assertThat(dto.getFileUuid()).isEqualTo(TEST_FILE_UUID_1);
List<DbFileSources.Test> tests = dto.getTestData();
assertThat(tests).hasSize(1);
underTest.execute();
- FileSourceDto dto = dbClient.fileSourceDao().selectTest(TEST_FILE_UUID_1);
+ FileSourceDto dto = dbClient.fileSourceDao().selectTest(db.getSession(), TEST_FILE_UUID_1);
List<Integer> coveredLines = dto.getTestData().get(0).getCoveredFile(0).getCoveredLineList();
assertThat(coveredLines).containsOnly(1, 2, 3, 4);
}
.setCreatedAt(100_000)
.setUpdatedAt(100_000));
db.getSession().commit();
- assertThat(dbClient.fileSourceDao().selectTest(TEST_FILE_UUID_1)).isNotNull();
+ assertThat(dbClient.fileSourceDao().selectTest(db.getSession(), TEST_FILE_UUID_1)).isNotNull();
ScannerReport.Test newBatchTest = newTest(1);
reportReader.putTests(TEST_FILE_REF_1, Arrays.asList(newBatchTest));
underTest.execute();
// ASSERT
- FileSourceDto dto = dbClient.fileSourceDao().selectTest(TEST_FILE_UUID_1);
+ FileSourceDto dto = dbClient.fileSourceDao().selectTest(db.getSession(), TEST_FILE_UUID_1);
assertThat(dto.getCreatedAt()).isEqualTo(100_000);
assertThat(dto.getUpdatedAt()).isEqualTo(now);
assertThat(dto.getTestData()).hasSize(1);
}
private void addActions() {
- actions.add(new org.sonar.server.issue.AssignAction(new DefaultUserFinder(db.getDbClient().userDao()), issueFieldsSetter));
+ actions.add(new org.sonar.server.issue.AssignAction(new DefaultUserFinder(db.getDbClient()), issueFieldsSetter));
actions.add(new org.sonar.server.issue.SetSeverityAction(issueFieldsSetter, userSession));
actions.add(new org.sonar.server.issue.SetTypeAction(issueFieldsSetter, userSession));
actions.add(new org.sonar.server.issue.TransitionAction(new TransitionService(userSession, issueWorkflow)));
@Rule
public DbTester dbTester = DbTester.create(System2.INSTANCE);
- BackendCleanup backendCleanup = new BackendCleanup(esTester.client(), dbTester.myBatis());
+ private BackendCleanup underTest = new BackendCleanup(esTester.client(), dbTester.getDbClient());
private OrganizationDto organization;
@Before
public void clear_db() {
dbTester.prepareDbUnit(getClass(), "shared.xml");
- backendCleanup.clearDb();
+ underTest.clearDb();
assertThat(dbTester.countRowsOfTable("projects")).isEqualTo(0);
assertThat(dbTester.countRowsOfTable("snapshots")).isEqualTo(0);
esTester.putDocuments(RuleIndexDefinition.INDEX_TYPE_RULE, newRuleDoc());
esTester.putDocuments(ComponentIndexDefinition.INDEX_TYPE_COMPONENT, newComponentDoc());
- backendCleanup.clearIndexes();
+ underTest.clearIndexes();
assertThat(esTester.countDocuments(IssueIndexDefinition.INDEX_TYPE_ISSUE)).isEqualTo(0);
assertThat(esTester.countDocuments(ComponentIndexDefinition.INDEX_TYPE_COMPONENT)).isEqualTo(0);
esTester.putDocuments(RuleIndexDefinition.INDEX_TYPE_RULE, newRuleDoc());
esTester.putDocuments(ComponentIndexDefinition.INDEX_TYPE_COMPONENT, newComponentDoc());
- backendCleanup.clearAll();
+ underTest.clearAll();
assertThat(esTester.countDocuments(IssueIndexDefinition.INDEX_TYPE_ISSUE)).isEqualTo(0);
assertThat(esTester.countDocuments(RuleIndexDefinition.INDEX_TYPE_RULE)).isEqualTo(0);
.setName("Name"));
esTester.putDocuments(ComponentIndexDefinition.INDEX_TYPE_COMPONENT, newComponentDoc());
- backendCleanup.resetData();
+ underTest.resetData();
assertThat(dbTester.countRowsOfTable("projects")).isZero();
assertThat(dbTester.countRowsOfTable("snapshots")).isZero();
@Rule
public DbTester db = DbTester.create(System2.INSTANCE);
- DbClient dbClient = db.getDbClient();
- DbSession dbSession = db.getSession();
-
- QualityGateUpdater underTest = new QualityGateUpdater(dbClient);
+ private DbClient dbClient = db.getDbClient();
+ private DbSession dbSession = db.getSession();
+ private QualityGateUpdater underTest = new QualityGateUpdater(dbClient);
@Test
public void create_quality_gate() throws Exception {
public void fail_to_create_when_name_is_empty() throws Exception {
expectedException.expect(BadRequestException.class);
expectedException.expectMessage("Name can't be empty");
+
underTest.create(dbSession, "");
}
@Test
public void fail_to_create_when_name_already_exists() throws Exception {
- dbClient.qualityGateDao().insert(new QualityGateDto().setName(QGATE_NAME));
+ dbClient.qualityGateDao().insert(dbSession, new QualityGateDto().setName(QGATE_NAME));
+ dbSession.commit();
expectedException.expect(BadRequestException.class);
expectedException.expectMessage("Name has already been taken");
+
underTest.create(dbSession, QGATE_NAME);
}
}
@Test
public void should_list_qgates() {
List<QualityGateDto> allQgates = Lists.newArrayList(new QualityGateDto().setName("Gate One"), new QualityGateDto().setName("Gate Two"));
- when(dao.selectAll()).thenReturn(allQgates);
+ when(dao.selectAll(dbSession)).thenReturn(allQgates);
assertThat(underTest.list()).isEqualTo(allQgates);
}
long id = QUALITY_GATE_ID;
final String name = "Golden";
QualityGateDto existing = new QualityGateDto().setId(id).setName(name);
- when(dao.selectByName(name)).thenReturn(existing);
+ when(dao.selectByName(dbSession, name)).thenReturn(existing);
assertThat(underTest.get(name)).isEqualTo(existing);
- verify(dao).selectByName(name);
+ verify(dao).selectByName(dbSession, name);
}
@Test(expected = NotFoundException.class)
QualityGateDto sg1 = underTest.rename(id, name);
assertThat(sg1.getName()).isEqualTo(name);
verify(dao).selectById(dbSession, id);
- verify(dao).selectByName(name);
- verify(dao).update(sg1);
+ verify(dao).selectByName(dbSession, name);
+ verify(dao).update(sg1, dbSession);
}
@Test
QualityGateDto sg1 = underTest.rename(id, name);
assertThat(sg1.getName()).isEqualTo(name);
verify(dao).selectById(dbSession, id);
- verify(dao).selectByName(name);
- verify(dao).update(sg1);
+ verify(dao).selectByName(dbSession, name);
+ verify(dao).update(sg1, dbSession);
}
@Test(expected = NotFoundException.class)
String name = "SG-1";
QualityGateDto existing = new QualityGateDto().setId(id).setName("Golden");
when(dao.selectById(dbSession, id)).thenReturn(existing);
- when(dao.selectByName(name)).thenReturn(new QualityGateDto().setId(666L).setName(name));
+ when(dao.selectByName(dbSession, name)).thenReturn(new QualityGateDto().setId(666L).setName(name));
underTest.rename(id, name);
}
long defaultId = QUALITY_GATE_ID;
when(propertiesDao.selectGlobalProperty("sonar.qualitygate")).thenReturn(new PropertyDto().setValue(Long.toString(defaultId)));
QualityGateDto defaultQgate = new QualityGateDto().setId(defaultId).setName(defaultName);
- when(dao.selectById(defaultId)).thenReturn(defaultQgate);
+ when(dao.selectById(dbSession, defaultId)).thenReturn(defaultQgate);
assertThat(underTest.getDefault()).isEqualTo(defaultQgate);
}
QualityGateConditionDto cond1 = new QualityGateConditionDto().setMetricId(metric1Id);
QualityGateConditionDto cond2 = new QualityGateConditionDto().setMetricId(metric2Id);
Collection<QualityGateConditionDto> conditions = ImmutableList.of(cond1, cond2);
- when(conditionDao.selectForQualityGate(qGateId)).thenReturn(conditions);
+ when(conditionDao.selectForQualityGate(dbSession, qGateId)).thenReturn(conditions);
Metric metric1 = mock(Metric.class);
when(metric1.getKey()).thenReturn(metric1Key);
when(metricFinder.findById((int) metric1Id)).thenReturn(metric1);
QualityGateConditionDto cond1 = new QualityGateConditionDto().setMetricId(metric1Id);
QualityGateConditionDto cond2 = new QualityGateConditionDto().setMetricId(metric2Id);
Collection<QualityGateConditionDto> conditions = ImmutableList.of(cond1, cond2);
- when(conditionDao.selectForQualityGate(qGateId)).thenReturn(conditions);
+ when(conditionDao.selectForQualityGate(dbSession, qGateId)).thenReturn(conditions);
Metric metric1 = mock(Metric.class);
when(metric1.getKey()).thenReturn(metric1Key);
when(metricFinder.findById((int) metric1Id)).thenReturn(metric1);
public void should_delete_condition() {
long idToDelete = QUALITY_GATE_ID;
QualityGateConditionDto toDelete = new QualityGateConditionDto().setId(idToDelete);
- when(conditionDao.selectById(idToDelete)).thenReturn(toDelete);
+ when(conditionDao.selectById(idToDelete, dbSession)).thenReturn(toDelete);
underTest.deleteCondition(idToDelete);
- verify(conditionDao).selectById(idToDelete);
- verify(conditionDao).delete(toDelete);
+ verify(conditionDao).selectById(idToDelete, dbSession);
+ verify(conditionDao).delete(toDelete, dbSession);
}
@Test(expected = NotFoundException.class)
((QualityGateDto) invocation.getArguments()[1]).setId(destId);
return null;
}).when(dao).insert(eq(dbSession), any(QualityGateDto.class));
- when(conditionDao.selectForQualityGate(anyLong(), eq(dbSession))).thenReturn(conditions);
+ when(conditionDao.selectForQualityGate(eq(dbSession), anyLong())).thenReturn(conditions);
QualityGateDto atlantis = underTest.copy(sourceId, name);
assertThat(atlantis.getName()).isEqualTo(name);
- verify(dao).selectByName(name);
+ verify(dao).selectByName(dbSession, name);
verify(dao).insert(dbSession, atlantis);
- verify(conditionDao).selectForQualityGate(anyLong(), eq(dbSession));
+ verify(conditionDao).selectForQualityGate(eq(dbSession), anyLong());
verify(conditionDao, times(conditions.size())).insert(any(QualityGateConditionDto.class), eq(dbSession));
}
assertThat(dbClient.loadedTemplateDao().countByTypeAndKey("QUALITY_GATE", "SonarQube way", dbSession)).isEqualTo(1);
QualityGateDto qualityGateDto = dbClient.qualityGateDao().selectByName(dbSession, "SonarQube way");
assertThat(qualityGateDto).isNotNull();
- assertThat(dbClient.gateConditionDao().selectForQualityGate(qualityGateDto.getId()))
+ assertThat(dbClient.gateConditionDao().selectForQualityGate(dbSession, qualityGateDto.getId()))
.extracting(QualityGateConditionDto::getMetricId, QualityGateConditionDto::getOperator, QualityGateConditionDto::getWarningThreshold,
QualityGateConditionDto::getErrorThreshold, QualityGateConditionDto::getPeriod)
.containsOnly(
assertThat(response.getName()).isEqualTo("Default");
assertThat(response.getId()).isNotNull();
dbSession.commit();
- QualityGateDto qualityGateDto = dbClient.qualityGateDao().selectByName("Default");
+ QualityGateDto qualityGateDto = dbClient.qualityGateDao().selectByName(dbSession, "Default");
assertThat(qualityGateDto).isNotNull();
}
}
private void assertCondition(CreateConditionWsResponse response, String operator, @Nullable String warning, @Nullable String error, @Nullable Integer period) {
- List<QualityGateConditionDto> conditionDtoList = new ArrayList<>(dbClient.gateConditionDao().selectForQualityGate(qualityGateDto.getId(), dbSession));
+ List<QualityGateConditionDto> conditionDtoList = new ArrayList<>(dbClient.gateConditionDao().selectForQualityGate(dbSession, qualityGateDto.getId()));
assertThat(conditionDtoList).hasSize(1);
QualityGateConditionDto qualityGateConditionDto = conditionDtoList.get(0);
assertThat(qualityGateConditionDto.getQualityGateId()).isEqualTo(qualityGateDto.getId());
}
private void assertCondition(CreateConditionWsResponse response, String operator, @Nullable String warning, @Nullable String error, @Nullable Integer period) {
- List<QualityGateConditionDto> conditionDtoList = new ArrayList<>(dbClient.gateConditionDao().selectForQualityGate(qualityGateDto.getId(), dbSession));
+ List<QualityGateConditionDto> conditionDtoList = new ArrayList<>(dbClient.gateConditionDao().selectForQualityGate(dbSession, qualityGateDto.getId()));
assertThat(conditionDtoList).hasSize(1);
QualityGateConditionDto qualityGateConditionDto = conditionDtoList.get(0);
assertThat(qualityGateConditionDto.getQualityGateId()).isEqualTo(qualityGateDto.getId());
+++ /dev/null
-/*
- * SonarQube
- * Copyright (C) 2009-2017 SonarSource SA
- * mailto:info AT sonarsource DOT com
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 3 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-package org.sonar.server.qualityprofile;
-
-import org.junit.Rule;
-import org.junit.Test;
-import org.sonar.api.utils.System2;
-import org.sonar.db.DbTester;
-import org.sonar.db.component.ComponentDto;
-import org.sonar.db.component.ComponentTesting;
-import org.sonar.db.qualityprofile.QualityProfileDao;
-import org.sonar.db.qualityprofile.QualityProfileDto;
-import org.sonar.db.qualityprofile.QualityProfileTesting;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-
-public class QProfilesTest {
-
- private static final String PROJECT_UUID = "P1";
-
- @Rule
- public DbTester dbTester = DbTester.create(System2.INSTANCE);
-
- private QProfileLookup profileLookup = mock(QProfileLookup.class);
- private QProfiles underTest = new QProfiles(profileLookup, dbTester.getDbClient());
-
- @Test
- public void search_profiles() {
- underTest.allProfiles();
- verify(profileLookup).allProfiles();
- }
-
- @Test
- public void search_profiles_by_language() {
- underTest.profilesByLanguage("java");
- verify(profileLookup).profiles("java");
- }
-
- @Test
- public void findProfileByProjectAndLanguage() {
- ComponentDto project = ComponentTesting.newProjectDto(dbTester.organizations().insert(), PROJECT_UUID);
- dbTester.getDbClient().componentDao().insert(dbTester.getSession(), project);
- QualityProfileDao qProfileDao = dbTester.getDbClient().qualityProfileDao();
- QualityProfileDto profile = QualityProfileTesting.newQualityProfileDto().setLanguage("js");
- qProfileDao.insert(dbTester.getSession(), profile);
- qProfileDao.insertProjectProfileAssociation(PROJECT_UUID, profile.getKey(), dbTester.getSession());
- dbTester.commit();
-
- assertThat(underTest.findProfileByProjectAndLanguage(1, "java")).isNull();
- assertThat(underTest.findProfileByProjectAndLanguage(project.getId(), "java")).isNull();
- assertThat(underTest.findProfileByProjectAndLanguage(project.getId(), "js").key()).isEqualTo(profile.getKey());
- }
-}
// TODO replace this MediumTest by DbTester and EsTester
public class RegisterQualityProfilesMediumTest {
- ServerTester tester;
- DbSession dbSession;
+ private ServerTester tester;
+ private DbSession dbSession;
@After
public void tearDown() {
tester.start();
QualityProfileDao profileDao = dbClient().qualityProfileDao();
- DbSession session = dbClient().openSession(false);
- QualityProfileDto profileTwo = profileDao.selectByNameAndLanguage("two", "xoo", session);
- tester.get(QProfileFactory.class).setDefault(session, profileTwo.getKee());
- session.commit();
+ dbSession = dbClient().openSession(false);
+ QualityProfileDto profileTwo = profileDao.selectByNameAndLanguage("two", "xoo", dbSession);
+ tester.get(QProfileFactory.class).setDefault(dbSession, profileTwo.getKee());
+ dbSession.commit();
verifyDefaultProfile("xoo", "two");
}
private void verifyDefaultProfile(String language, String name) {
- QualityProfileDto defaultProfile = dbClient().qualityProfileDao().selectDefaultProfile(language);
+ dbSession = dbClient().openSession(false);
+ QualityProfileDto defaultProfile = dbClient().qualityProfileDao().selectDefaultProfile(dbSession, language);
assertThat(defaultProfile).isNotNull();
assertThat(defaultProfile.getName()).isEqualTo(name);
}
tester.newPostRequest("api/qualityprofiles", "delete").setParam("profileKey", "sonar-way-xoo1-12345").execute().assertNoContent();
assertThat(qualityProfileDao.selectByKey(session, "sonar-way-xoo1-12345")).isNull();
- assertThat(qualityProfileDao.selectProjects("Sonar way", xoo1.getName())).isEmpty();
+ assertThat(qualityProfileDao.selectProjects("Sonar way", xoo1.getName(), session)).isEmpty();
}
@Test
tester.newPostRequest("api/qualityprofiles", "delete").setParam("profileName", "Sonar way").setParam("language", xoo1.getKey()).execute().assertNoContent();
assertThat(qualityProfileDao.selectByKey(session, "sonar-way-xoo1-12345")).isNull();
- assertThat(qualityProfileDao.selectProjects("Sonar way", xoo1.getName())).isEmpty();
+ assertThat(qualityProfileDao.selectProjects("Sonar way", xoo1.getName(), session)).isEmpty();
}
@Test
}
private void checkDefaultProfile(String language, String key) {
- assertThat(dbClient.qualityProfileDao().selectDefaultProfile(language).getKey()).isEqualTo(key);
+ assertThat(dbClient.qualityProfileDao().selectDefaultProfile(db.getSession(), language).getKey()).isEqualTo(key);
}
}
FileSourceDto dto = new FileSourceDto();
dto.setFileUuid(FILE_UUID).setProjectUuid("PROJECT_UUID");
dto.setSourceData(FileSourceTesting.newFakeData(10).build());
- dbTester.getDbClient().fileSourceDao().insert(dto);
+ dbTester.getDbClient().fileSourceDao().insert(dbTester.getSession(), dto);
+ dbTester.commit();
}
@Test
private void insertFileWithData(DbFileSources.Data fileData) throws IOException {
insertFile();
- dbTester.getDbClient().fileSourceDao().insert(new FileSourceDto()
+ dbTester.getDbClient().fileSourceDao().insert(dbTester.getSession(), new FileSourceDto()
.setProjectUuid(PROJECT_UUID)
.setFileUuid(FILE_UUID)
.setSourceData(fileData));
+ dbTester.commit();
}
private void setUserWithValidPermission() {
import org.sonar.api.utils.System2;
import org.sonar.api.web.UserRole;
import org.sonar.db.DbClient;
+import org.sonar.db.DbSession;
import org.sonar.db.DbTester;
import org.sonar.db.component.ComponentDto;
import org.sonar.db.component.ComponentTesting;
@Rule
public UserSessionRule userSessionRule = UserSessionRule.standalone();
- WsTester tester;
-
- DbClient dbClient = dbTester.getDbClient();
+ private WsTester tester;
+ private DbClient dbClient = dbTester.getDbClient();
+ private DbSession dbSession = dbTester.getSession();
@Before
public void setUp() {
initFile();
userSessionRule.addProjectUuidPermissions(UserRole.CODEVIEWER, PROJECT_UUID);
- dbTester.getDbClient().fileSourceDao().insert(new FileSourceDto()
+ dbTester.getDbClient().fileSourceDao().insert(dbSession, new FileSourceDto()
.setProjectUuid(PROJECT_UUID)
.setFileUuid(FILE_UUID)
.setSourceData(DbFileSources.Data.newBuilder().addLines(
newSourceLine("julien", "123-456-789", DateUtils.parseDateTime("2015-03-30T12:34:56+0000"), 1)).build()));
+ dbSession.commit();
WsTester.TestRequest request = tester.newGetRequest("api/sources", "scm").setParam("key", FILE_KEY);
request.execute().assertJson(getClass(), "show_scm.json");
initFile();
userSessionRule.addProjectUuidPermissions(UserRole.CODEVIEWER, PROJECT_UUID);
- dbTester.getDbClient().fileSourceDao().insert(new FileSourceDto()
+ dbTester.getDbClient().fileSourceDao().insert(dbSession, new FileSourceDto()
.setProjectUuid(PROJECT_UUID)
.setFileUuid(FILE_UUID)
.setSourceData(DbFileSources.Data.newBuilder()
.addLines(newSourceLine("julien", "456-789-101", DateUtils.parseDateTime("2015-03-27T12:34:56+0000"), 3))
.addLines(newSourceLine("simon", "789-101-112", DateUtils.parseDateTime("2015-03-31T12:34:56+0000"), 4))
.build()));
+ dbSession.commit();
WsTester.TestRequest request = tester.newGetRequest("api/sources", "scm").setParam("key", FILE_KEY).setParam("from", "2").setParam("to", "3");
request.execute().assertJson(getClass(), "show_scm_from_given_range_lines.json");
userSessionRule.addProjectUuidPermissions(UserRole.CODEVIEWER, PROJECT_UUID);
// lines 1 and 2 are the same commit, but not 3 (different date)
- dbTester.getDbClient().fileSourceDao().insert(new FileSourceDto()
+ dbTester.getDbClient().fileSourceDao().insert(dbSession, new FileSourceDto()
.setProjectUuid(PROJECT_UUID)
.setFileUuid(FILE_UUID)
.setSourceData(DbFileSources.Data.newBuilder()
.addLines(newSourceLine("julien", "456-789-101", DateUtils.parseDateTime("2015-03-27T12:34:56+0000"), 3))
.addLines(newSourceLine("simon", "789-101-112", DateUtils.parseDateTime("2015-03-31T12:34:56+0000"), 4))
.build()));
+ dbSession.commit();
WsTester.TestRequest request = tester.newGetRequest("api/sources", "scm").setParam("key", FILE_KEY).setParam("commits_by_line",
"true");
userSessionRule.addProjectUuidPermissions(UserRole.CODEVIEWER, PROJECT_UUID);
// lines 1 and 2 are the same commit, but not 3 (different date)
- dbTester.getDbClient().fileSourceDao().insert(new FileSourceDto()
+ dbTester.getDbClient().fileSourceDao().insert(dbSession, new FileSourceDto()
.setProjectUuid(PROJECT_UUID)
.setFileUuid(FILE_UUID)
.setSourceData(DbFileSources.Data.newBuilder()
.addLines(newSourceLine("julien", "456-789-101", DateUtils.parseDateTime("2015-03-27T12:34:56+0000"), 3))
.addLines(newSourceLine("simon", "789-101-112", DateUtils.parseDateTime("2015-03-31T12:34:56+0000"), 4))
.build()));
+ dbSession.commit();
WsTester.TestRequest request = tester.newGetRequest("api/sources", "scm").setParam("key", FILE_KEY).setParam("commits_by_line",
"false");
initFile();
userSessionRule.addProjectUuidPermissions(UserRole.CODEVIEWER, PROJECT_UUID);
- dbTester.getDbClient().fileSourceDao().insert(new FileSourceDto()
+ dbTester.getDbClient().fileSourceDao().insert(dbSession, new FileSourceDto()
.setProjectUuid(PROJECT_UUID)
.setFileUuid(FILE_UUID)
.setSourceData(DbFileSources.Data.newBuilder()
.addLines(newSourceLine("julien", "456-789-101", DateUtils.parseDateTime("2015-03-27T12:34:56+0000"), 3))
.addLines(newSourceLine("simon", "789-101-112", DateUtils.parseDateTime("2015-03-31T12:34:56+0000"), 4))
.build()));
+ dbSession.commit();
WsTester.TestRequest request = tester.newGetRequest("api/sources", "scm").setParam("key", FILE_KEY).setParam("from",
"-2").setParam("to", "3");
initFile();
userSessionRule.addProjectUuidPermissions(UserRole.CODEVIEWER, PROJECT_UUID);
- dbTester.getDbClient().fileSourceDao().insert(new FileSourceDto()
+ dbTester.getDbClient().fileSourceDao().insert(dbSession, new FileSourceDto()
.setProjectUuid(PROJECT_UUID)
.setFileUuid(FILE_UUID)
.setSourceData(DbFileSources.Data.newBuilder().build()));
+ dbSession.commit();
WsTester.TestRequest request = tester.newGetRequest("api/sources", "scm").setParam("key", FILE_KEY);
request.execute().assertJson(getClass(), "return_empty_value_when_no_scm.json");
}
private void verifyTaskRegistered() {
- assertThat(dbClient.loadedTemplateDao().countByTypeAndKey(ONE_SHOT_TASK_TYPE, "ClearRulesOverloadedDebt")).isEqualTo(1);
+ assertThat(dbClient.loadedTemplateDao().countByTypeAndKey(ONE_SHOT_TASK_TYPE, "ClearRulesOverloadedDebt", dbSession)).isEqualTo(1);
}
private void verifyLog() {
}
private void insertTests(ComponentDto testFile, DbFileSources.Test... tests) {
- db.getDbClient().fileSourceDao().insert(new FileSourceDto()
+ db.getDbClient().fileSourceDao().insert(db.getSession(), new FileSourceDto()
.setProjectUuid(project.uuid())
.setFileUuid(testFile.uuid())
.setTestData(asList(tests)));
+++ /dev/null
-/*
- * SonarQube
- * Copyright (C) 2009-2017 SonarSource SA
- * mailto:info AT sonarsource DOT com
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 3 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-package org.sonar.server.user;
-
-import java.util.Arrays;
-import java.util.Collection;
-import org.junit.Test;
-import org.sonar.api.user.User;
-import org.sonar.api.user.UserQuery;
-import org.sonar.db.user.UserDao;
-import org.sonar.db.user.UserDto;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-public class DefaultUserFinderTest {
- UserDao dao = mock(UserDao.class);
- DefaultUserFinder finder = new DefaultUserFinder(dao);
-
- @Test
- public void findByLogin() {
- UserDto dto = new UserDto().setLogin("david").setName("David").setEmail("dav@id.com");
- when(dao.selectActiveUserByLogin("david")).thenReturn(dto);
-
- assertThat(finder.findByLogin("david").name()).isEqualTo("David");
- }
-
- @Test
- public void findByLogins() {
- UserDto david = new UserDto().setLogin("david").setName("David").setEmail("dav@id.com");
- UserDto john = new UserDto().setLogin("john").setName("John").setEmail("jo@hn.com");
- when(dao.selectByLogins(Arrays.asList("david", "john"))).thenReturn(Arrays.asList(david, john));
-
- Collection<User> users = finder.findByLogins(Arrays.asList("david", "john"));
- assertThat(users).hasSize(2);
- for (User user : users) {
- assertThat(user.login()).isIn("david", "john");
- }
- }
-
- @Test
- public void findByQuery() {
- UserQuery query = UserQuery.builder().logins("simon").build();
- finder.find(query);
- verify(dao).selectUsers(query);
- }
-}
import org.sonar.api.database.model.User;
import org.sonar.api.utils.System2;
import org.sonar.db.DbTester;
-import org.sonar.db.user.UserDao;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.nullValue;
import static org.junit.Assert.assertThat;
-import static org.mockito.Mockito.mock;
public class DeprecatedUserFinderTest {
@Rule
public DbTester dbTester = DbTester.create(System2.INSTANCE);
-
+ private DeprecatedUserFinder underTest = new DeprecatedUserFinder(dbTester.getDbClient());
+
@Before
public void init() {
dbTester.prepareDbUnit(DeprecatedUserFinderTest.class, "fixture.xml");
@Test
public void shouldFindUserByLogin() {
- DeprecatedUserFinder finder = new DeprecatedUserFinder(new UserDao(dbTester.myBatis(), mock(System2.class)));
- User user = finder.findByLogin("simon");
+
+ User user = underTest.findByLogin("simon");
assertThat(user.getId(), is(1));
assertThat(user.getLogin(), is("simon"));
assertThat(user.getName(), is("Simon Brandhof"));
assertThat(user.getEmail(), is("simon.brandhof@sonarsource.com"));
- user = finder.findByLogin("godin");
+ user = underTest.findByLogin("godin");
assertThat(user.getId(), is(2));
assertThat(user.getLogin(), is("godin"));
assertThat(user.getName(), is("Evgeny Mandrikov"));
assertThat(user.getEmail(), is("evgeny.mandrikov@sonarsource.com"));
- user = finder.findByLogin("user");
+ user = underTest.findByLogin("user");
assertThat(user, nullValue());
}
@Test
public void shouldFindUserById() {
- DeprecatedUserFinder finder = new DeprecatedUserFinder(new UserDao(dbTester.myBatis(), mock(System2.class)));
- User user = finder.findById(1);
+ User user = underTest.findById(1);
assertThat(user.getId(), is(1));
assertThat(user.getLogin(), is("simon"));
assertThat(user.getName(), is("Simon Brandhof"));
assertThat(user.getEmail(), is("simon.brandhof@sonarsource.com"));
- user = finder.findById(2);
+ user = underTest.findById(2);
assertThat(user.getId(), is(2));
assertThat(user.getLogin(), is("godin"));
assertThat(user.getName(), is("Evgeny Mandrikov"));
assertThat(user.getEmail(), is("evgeny.mandrikov@sonarsource.com"));
- user = finder.findById(3);
+ user = underTest.findById(3);
assertThat(user, nullValue());
}
}
@VisibleForTesting
- App(Properties commandLineArguments, Function<Properties, Props> propsSupplier, Monitor monitor, CheckFSConfigOnReload checkFsConfigOnReload, JavaCommandFactory javaCommandFactory) {
+ App(Properties commandLineArguments, Function<Properties, Props> propsSupplier, Monitor monitor, CheckFSConfigOnReload checkFsConfigOnReload,
+ JavaCommandFactory javaCommandFactory) {
this.commandLineArguments = commandLineArguments;
this.propsSupplier = propsSupplier;
this.javaCommandFactory = javaCommandFactory;
monitor.awaitTermination();
}
- private List<JavaCommand> createCommands(Props props) {
- File homeDir = props.nonNullValueAsFile(ProcessProperties.PATH_HOME);
- List<JavaCommand> commands = new ArrayList<>(3);
- if (isProcessEnabled(props, ProcessProperties.CLUSTER_SEARCH_DISABLED)) {
- commands.add(javaCommandFactory.createESCommand(props, homeDir));
- }
-
- if (isProcessEnabled(props, ProcessProperties.CLUSTER_WEB_DISABLED)) {
- commands.add(javaCommandFactory.createWebCommand(props, homeDir));
- }
-
- if (isProcessEnabled(props, ProcessProperties.CLUSTER_CE_DISABLED)) {
- commands.add(javaCommandFactory.createCeCommand(props, homeDir));
- }
-
- return commands;
- }
-
private static boolean isProcessEnabled(Props props, String disabledPropertyKey) {
return !props.valueAsBoolean(ProcessProperties.CLUSTER_ENABLED) ||
!props.valueAsBoolean(disabledPropertyKey);
return createCommands(reloadedProps);
}
+
+ private List<JavaCommand> createCommands(Props props) {
+ File homeDir = props.nonNullValueAsFile(ProcessProperties.PATH_HOME);
+ List<JavaCommand> commands = new ArrayList<>(3);
+ if (isProcessEnabled(props, ProcessProperties.CLUSTER_SEARCH_DISABLED)) {
+ commands.add(javaCommandFactory.createESCommand(props, homeDir));
+ }
+
+ if (isProcessEnabled(props, ProcessProperties.CLUSTER_WEB_DISABLED)) {
+ commands.add(javaCommandFactory.createWebCommand(props, homeDir));
+ }
+
+ if (isProcessEnabled(props, ProcessProperties.CLUSTER_CE_DISABLED)) {
+ commands.add(javaCommandFactory.createCeCommand(props, homeDir));
+ }
+
+ return commands;
+ }
}
}
@Override
public JavaCommand createESCommand(Props props, File workDir) {
- return newJavaCommand(ProcessId.ELASTICSEARCH, props, workDir)
- .addJavaOptions("-Djava.awt.headless=true")
- .addJavaOptions(props.nonNullValue(ProcessProperties.SEARCH_JAVA_OPTS))
- .addJavaOptions(props.nonNullValue(ProcessProperties.SEARCH_JAVA_ADDITIONAL_OPTS))
- .setClassName("org.sonar.search.SearchServer")
- .addClasspath("./lib/common/*")
- .addClasspath("./lib/search/*");
- }
+ return newJavaCommand(ProcessId.ELASTICSEARCH, props, workDir)
+ .addJavaOptions("-Djava.awt.headless=true")
+ .addJavaOptions(props.nonNullValue(ProcessProperties.SEARCH_JAVA_OPTS))
+ .addJavaOptions(props.nonNullValue(ProcessProperties.SEARCH_JAVA_ADDITIONAL_OPTS))
+ .setClassName("org.sonar.search.SearchServer")
+ .addClasspath("./lib/common/*")
+ .addClasspath("./lib/search/*");
+ }
@Override
public JavaCommand createWebCommand(Props props, File workDir) {
- JavaCommand command = newJavaCommand(ProcessId.WEB_SERVER, props, workDir)
- .addJavaOptions(ProcessProperties.WEB_ENFORCED_JVM_ARGS)
- .addJavaOptions(props.nonNullValue(ProcessProperties.WEB_JAVA_OPTS))
- .addJavaOptions(props.nonNullValue(ProcessProperties.WEB_JAVA_ADDITIONAL_OPTS))
- // required for logback tomcat valve
- .setEnvVariable(ProcessProperties.PATH_LOGS, props.nonNullValue(ProcessProperties.PATH_LOGS))
- .setClassName("org.sonar.server.app.WebServer")
- .addClasspath("./lib/common/*")
- .addClasspath("./lib/server/*");
- String driverPath = props.value(ProcessProperties.JDBC_DRIVER_PATH);
- if (driverPath != null) {
- command.addClasspath(driverPath);
- }
- return command;
+ JavaCommand command = newJavaCommand(ProcessId.WEB_SERVER, props, workDir)
+ .addJavaOptions(ProcessProperties.WEB_ENFORCED_JVM_ARGS)
+ .addJavaOptions(props.nonNullValue(ProcessProperties.WEB_JAVA_OPTS))
+ .addJavaOptions(props.nonNullValue(ProcessProperties.WEB_JAVA_ADDITIONAL_OPTS))
+ // required for logback tomcat valve
+ .setEnvVariable(ProcessProperties.PATH_LOGS, props.nonNullValue(ProcessProperties.PATH_LOGS))
+ .setClassName("org.sonar.server.app.WebServer")
+ .addClasspath("./lib/common/*")
+ .addClasspath("./lib/server/*");
+ String driverPath = props.value(ProcessProperties.JDBC_DRIVER_PATH);
+ if (driverPath != null) {
+ command.addClasspath(driverPath);
}
+ return command;
+ }
@Override
public JavaCommand createCeCommand(Props props, File workDir) {
- JavaCommand command = newJavaCommand(ProcessId.COMPUTE_ENGINE, props, workDir)
- .addJavaOptions(ProcessProperties.CE_ENFORCED_JVM_ARGS)
- .addJavaOptions(props.nonNullValue(ProcessProperties.CE_JAVA_OPTS))
- .addJavaOptions(props.nonNullValue(ProcessProperties.CE_JAVA_ADDITIONAL_OPTS))
- .setClassName("org.sonar.ce.app.CeServer")
- .addClasspath("./lib/common/*")
- .addClasspath("./lib/server/*")
- .addClasspath("./lib/ce/*");
- String driverPath = props.value(ProcessProperties.JDBC_DRIVER_PATH);
- if (driverPath != null) {
- command.addClasspath(driverPath);
- }
- return command;
+ JavaCommand command = newJavaCommand(ProcessId.COMPUTE_ENGINE, props, workDir)
+ .addJavaOptions(ProcessProperties.CE_ENFORCED_JVM_ARGS)
+ .addJavaOptions(props.nonNullValue(ProcessProperties.CE_JAVA_OPTS))
+ .addJavaOptions(props.nonNullValue(ProcessProperties.CE_JAVA_ADDITIONAL_OPTS))
+ .setClassName("org.sonar.ce.app.CeServer")
+ .addClasspath("./lib/common/*")
+ .addClasspath("./lib/server/*")
+ .addClasspath("./lib/ce/*");
+ String driverPath = props.value(ProcessProperties.JDBC_DRIVER_PATH);
+ if (driverPath != null) {
+ command.addClasspath(driverPath);
}
+ return command;
+ }
private static JavaCommand newJavaCommand(ProcessId id, Props props, File workDir) {
JavaCommand command = new JavaCommand(id)
projects / sonarqube.git / commitdiff