private final BatchIndex batchIndex;
private final GlobalReferentialsAction globalReferentialsAction;
+ private final ProjectReferentialsAction projectReferentialsAction;
- public BatchWs(BatchIndex batchIndex, GlobalReferentialsAction globalReferentialsAction) {
+ public BatchWs(BatchIndex batchIndex, GlobalReferentialsAction globalReferentialsAction, ProjectReferentialsAction projectReferentialsAction) {
this.batchIndex = batchIndex;
this.globalReferentialsAction = globalReferentialsAction;
+ this.projectReferentialsAction = projectReferentialsAction;
}
@Override
defineIndexAction(controller);
defineFileAction(controller);
globalReferentialsAction.define(controller);
+ projectReferentialsAction.define(controller);
controller.done();
}
}
}
- private boolean isPropertyAllowed(String key, boolean hasScanPerm, boolean hasDryRunPerm){
+ private static boolean isPropertyAllowed(String key, boolean hasScanPerm, boolean hasDryRunPerm) {
return !key.contains(".secured") || hasScanPerm || (key.contains(".license") && hasDryRunPerm);
}
--- /dev/null
+/*
+ * SonarQube, open source software quality management tool.
+ * Copyright (C) 2008-2014 SonarSource
+ * mailto:contact AT sonarsource DOT com
+ *
+ * SonarQube is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * SonarQube is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+package org.sonar.server.batch;
+
+import org.apache.commons.io.IOUtils;
+import org.sonar.api.resources.Language;
+import org.sonar.api.resources.Languages;
+import org.sonar.api.server.ws.Request;
+import org.sonar.api.server.ws.RequestHandler;
+import org.sonar.api.server.ws.Response;
+import org.sonar.api.server.ws.WebService;
+import org.sonar.batch.protocol.input.ProjectReferentials;
+import org.sonar.batch.protocol.input.QProfile;
+import org.sonar.core.UtcDateUtils;
+import org.sonar.core.component.ComponentDto;
+import org.sonar.core.permission.GlobalPermissions;
+import org.sonar.core.persistence.DbSession;
+import org.sonar.core.persistence.MyBatis;
+import org.sonar.core.properties.PropertiesDao;
+import org.sonar.core.properties.PropertyDto;
+import org.sonar.core.qualityprofile.db.QualityProfileDto;
+import org.sonar.server.db.DbClient;
+import org.sonar.server.plugins.MimeTypes;
+import org.sonar.server.qualityprofile.QProfileFactory;
+import org.sonar.server.user.UserSession;
+
+import java.util.List;
+import java.util.Map;
+
+import static com.google.common.collect.Maps.newHashMap;
+
+public class ProjectReferentialsAction implements RequestHandler {
+
+ private static final String PARAM_KEY = "key";
+
+ private final DbClient dbClient;
+ private final PropertiesDao propertiesDao;
+ private final QProfileFactory qProfileFactory;
+ private final Languages languages;
+
+ public ProjectReferentialsAction(DbClient dbClient, PropertiesDao propertiesDao, QProfileFactory qProfileFactory, Languages languages) {
+ this.dbClient = dbClient;
+ this.propertiesDao = propertiesDao;
+ this.qProfileFactory = qProfileFactory;
+ this.languages = languages;
+ }
+
+ void define(WebService.NewController controller) {
+ WebService.NewAction action = controller.createAction("project")
+ .setDescription("Return project referentials")
+ .setSince("4.5")
+ .setInternal(true)
+ .setHandler(this);
+
+ action
+ .createParam(PARAM_KEY)
+ .setRequired(true)
+ .setDescription("Project key")
+ .setExampleValue("org.codehaus.sonar:sonar");
+ }
+
+ @Override
+ public void handle(Request request, Response response) throws Exception {
+ UserSession userSession = UserSession.get();
+ boolean hasScanPerm = userSession.hasGlobalPermission(GlobalPermissions.SCAN_EXECUTION);
+
+ DbSession session = dbClient.openSession(false);
+ try {
+ ProjectReferentials ref = new ProjectReferentials();
+ String projectKey = request.mandatoryParam(PARAM_KEY);
+ addSettings(ref, projectKey, hasScanPerm, session);
+ addProfiles(ref, projectKey, session);
+
+ response.stream().setMediaType(MimeTypes.JSON);
+ IOUtils.write(ref.toJson(), response.stream().output());
+ } finally {
+ MyBatis.closeQuietly(session);
+ }
+ }
+
+ private void addSettings(ProjectReferentials ref, String projectKey, boolean hasScanPerm, DbSession session) {
+ addSettings(ref, projectKey, propertiesDao.selectProjectProperties(projectKey, session), hasScanPerm);
+ for (ComponentDto module : dbClient.componentDao().findModulesByProject(projectKey, session)) {
+ addSettings(ref, module.getKey(), propertiesDao.selectProjectProperties(module.getKey(), session), hasScanPerm);
+ }
+ }
+
+ private void addSettings(ProjectReferentials ref, String projectOrModuleKey, List<PropertyDto> propertyDtos, boolean hasScanPerm) {
+ Map<String, String> properties = newHashMap();
+ for (PropertyDto propertyDto : propertyDtos) {
+ String key = propertyDto.getKey();
+ String value = propertyDto.getValue();
+ if (isPropertyAllowed(key, hasScanPerm)) {
+ properties.put(key, value);
+ }
+ }
+ if (!properties.isEmpty()) {
+ ref.addSettings(projectOrModuleKey, properties);
+ }
+ }
+
+ private static boolean isPropertyAllowed(String key, boolean hasScanPerm) {
+ return !key.contains(".secured") || hasScanPerm;
+ }
+
+ private void addProfiles(ProjectReferentials ref, String projectKey, DbSession session) {
+ for (Language language : languages.all()) {
+ String languageKey = language.getKey();
+ QualityProfileDto qualityProfileDto = qProfileFactory.getByProjectAndLanguage(session, projectKey, languageKey);
+ qualityProfileDto = qualityProfileDto != null ? qualityProfileDto : qProfileFactory.getDefault(session, languageKey);
+ if (qualityProfileDto != null) {
+ QProfile profile = new QProfile(qualityProfileDto.getKey(), qualityProfileDto.getName(), qualityProfileDto.getLanguage(),
+ UtcDateUtils.parseDateTime(qualityProfileDto.getRulesUpdatedAt()));
+ ref.addQProfile(profile);
+ }
+ }
+ }
+
+}
*/
package org.sonar.server.component.persistence;
-import org.apache.ibatis.session.SqlSession;
import org.sonar.api.ServerComponent;
import org.sonar.api.utils.System2;
import org.sonar.core.component.ComponentDto;
import org.sonar.server.db.BaseDao;
import java.util.Date;
+import java.util.List;
/**
* @since 4.3
super(ComponentMapper.class, system);
}
- public ComponentDto getById(Long id, SqlSession session) {
- return getMapper(session).selectById(id);
+ public ComponentDto getById(Long id, DbSession session) {
+ return mapper(session).selectById(id);
}
- public boolean existsById(Long id, SqlSession session) {
- return getMapper(session).countById(id) > 0;
+ public boolean existsById(Long id, DbSession session) {
+ return mapper(session).countById(id) > 0;
}
- private ComponentMapper getMapper(SqlSession session) {
- return session.getMapper(ComponentMapper.class);
+ public List<ComponentDto> findModulesByProject(String projectKey, DbSession session) {
+ return mapper(session).findModulesByProject(projectKey);
}
@Override
protected ComponentDto doGetNullableByKey(DbSession session, String key) {
- return getMapper(session).selectByKey(key);
+ return mapper(session).selectByKey(key);
}
@Override
protected ComponentDto doInsert(DbSession session, ComponentDto item) {
- getMapper(session).insert(item);
+ mapper(session).insert(item);
return item;
}
import org.sonar.server.batch.BatchIndex;
import org.sonar.server.batch.BatchWs;
import org.sonar.server.batch.GlobalReferentialsAction;
+import org.sonar.server.batch.ProjectReferentialsAction;
import org.sonar.server.charts.ChartFactory;
import org.sonar.server.component.DefaultComponentFinder;
import org.sonar.server.component.DefaultRubyComponentService;
// batch
pico.addSingleton(BatchIndex.class);
pico.addSingleton(GlobalReferentialsAction.class);
+ pico.addSingleton(ProjectReferentialsAction.class);
pico.addSingleton(BatchWs.class);
// update center
}
@CheckForNull
- QualityProfileDto getDefault(DbSession session, String language) {
+ public QualityProfileDto getDefault(DbSession session, String language) {
return db.qualityProfileDao().getDefaultProfile(language, session);
}
db.propertiesDao().setProperty(property, session);
}
+ QualityProfileDto getByProjectAndLanguage(String projectKey, String language) {
+ DbSession dbSession = db.openSession(false);
+ try {
+ return getByProjectAndLanguage(dbSession, projectKey, language);
+ } finally {
+ dbSession.close();
+ }
+ }
+
+ public QualityProfileDto getByProjectAndLanguage(DbSession session, String projectKey, String language) {
+ return db.qualityProfileDao().getByProjectAndLanguage(projectKey, language, PROFILE_PROPERTY_PREFIX + language, session);
+ }
+
private void checkNotDefault(@Nullable QualityProfileDto defaultProfile, QualityProfileDto p) {
if (defaultProfile != null && defaultProfile.getKey().equals(p.getKey())) {
throw new BadRequestException("The profile marked as default can not be deleted: " + p.getKey());
checkPermission(userSession);
DbSession session = db.openSession(false);
try {
+ addProject(profileId, projectId, userSession, session);
+ session.commit();
+ } finally {
+ MyBatis.closeQuietly(session);
+ }
+ }
+
+ void addProject(int profileId, long projectId, UserSession userSession, DbSession session) {
+ checkPermission(userSession);
ComponentDto project = (ComponentDto) findProjectNotNull(projectId, session);
QualityProfileDto qualityProfile = findNotNull(profileId, session);
db.propertiesDao().setProperty(new PropertyDto().setKey(
QProfileProjectLookup.PROFILE_PROPERTY_PREFIX + qualityProfile.getLanguage()).setValue(qualityProfile.getName()).setResourceId(project.getId()), session);
session.commit();
- } finally {
- MyBatis.closeQuietly(session);
- }
}
public void removeProject(int profileId, long projectId, UserSession userSession) {
import java.util.List;
+/**
+ * Use {@link org.sonar.server.qualityprofile.QProfileService} instead
+ */
+@Deprecated
public class QProfiles implements ServerComponent {
private static final String LANGUAGE_PARAM = "language";
}
/**
- * Used in /project/profile
+ * Used in /project/profile and in /api/profiles
*/
@CheckForNull
public QProfile findProfileByProjectAndLanguage(long projectId, String language) {
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
+import org.sonar.api.resources.Languages;
import org.sonar.core.properties.PropertiesDao;
import org.sonar.server.db.DbClient;
+import org.sonar.server.qualityprofile.QProfileFactory;
import org.sonar.server.ws.WsTester;
import java.io.File;
@Before
public void before() throws IOException {
- tester = new WsTester(new BatchWs(batchIndex, new GlobalReferentialsAction(mock(DbClient.class), mock(PropertiesDao.class))));
+ tester = new WsTester(new BatchWs(batchIndex,
+ new GlobalReferentialsAction(mock(DbClient.class), mock(PropertiesDao.class)),
+ new ProjectReferentialsAction(mock(DbClient.class), mock(PropertiesDao.class), mock(QProfileFactory.class), mock(Languages.class))));
}
@Test
when(dbClient.openSession(false)).thenReturn(session);
when(dbClient.metricDao()).thenReturn(metricDao);
- tester = new WsTester(new BatchWs(mock(BatchIndex.class), new GlobalReferentialsAction(dbClient, propertiesDao)));
+ tester = new WsTester(new BatchWs(mock(BatchIndex.class), new GlobalReferentialsAction(dbClient, propertiesDao), mock(ProjectReferentialsAction.class)));
}
@Test
--- /dev/null
+/*
+ * SonarQube, open source software quality management tool.
+ * Copyright (C) 2008-2014 SonarSource
+ * mailto:contact AT sonarsource DOT com
+ *
+ * SonarQube is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * SonarQube is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+package org.sonar.server.batch;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.sonar.api.resources.Language;
+import org.sonar.api.resources.Languages;
+import org.sonar.core.component.ComponentDto;
+import org.sonar.core.permission.GlobalPermissions;
+import org.sonar.core.persistence.DbSession;
+import org.sonar.core.properties.PropertiesDao;
+import org.sonar.core.properties.PropertyDto;
+import org.sonar.core.qualityprofile.db.QualityProfileDto;
+import org.sonar.server.component.persistence.ComponentDao;
+import org.sonar.server.db.DbClient;
+import org.sonar.server.qualityprofile.QProfileFactory;
+import org.sonar.server.user.MockUserSession;
+import org.sonar.server.ws.WsTester;
+
+import static com.google.common.collect.Lists.newArrayList;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ProjectReferentialsActionTest {
+
+ @Mock
+ DbSession session;
+
+ @Mock
+ ComponentDao componentDao;
+
+ @Mock
+ PropertiesDao propertiesDao;
+
+ @Mock
+ QProfileFactory qProfileFactory;
+
+ @Mock
+ Languages languages;
+
+ @Mock
+ Language language;
+
+ WsTester tester;
+
+ @Before
+ public void setUp() throws Exception {
+ DbClient dbClient = mock(DbClient.class);
+ when(dbClient.openSession(false)).thenReturn(session);
+ when(dbClient.componentDao()).thenReturn(componentDao);
+
+ when(language.getKey()).thenReturn("java");
+ when(languages.all()).thenReturn(new Language[]{language});
+
+ tester = new WsTester(new BatchWs(mock(BatchIndex.class), mock(GlobalReferentialsAction.class), new ProjectReferentialsAction(dbClient, propertiesDao, qProfileFactory, languages)));
+ }
+
+ @Test
+ public void return_settings_by_modules() throws Exception {
+ MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION, GlobalPermissions.DRY_RUN_EXECUTION);
+ String projectKey = "org.codehaus.sonar:sonar";
+ String moduleKey = "org.codehaus.sonar:sonar-server";
+
+ when(componentDao.findModulesByProject(projectKey, session)).thenReturn(newArrayList(
+ new ComponentDto().setKey(projectKey),
+ new ComponentDto().setKey(moduleKey)
+ ));
+
+ when(propertiesDao.selectProjectProperties(projectKey, session)).thenReturn(newArrayList(
+ new PropertyDto().setKey("sonar.jira.project.key").setValue("SONAR"),
+ new PropertyDto().setKey("sonar.jira.login.secured").setValue("john")
+ ));
+
+ when(propertiesDao.selectProjectProperties(moduleKey, session)).thenReturn(newArrayList(
+ new PropertyDto().setKey("sonar.coverage.exclusions").setValue("**/*.java")
+ ));
+
+ WsTester.TestRequest request = tester.newGetRequest("batch", "project").setParam("key", projectKey);
+ request.execute().assertJson(getClass(), "return_settings_by_modules.json");
+ }
+
+ @Test
+ public void return_settings_by_modules_without_empty_module_settings() throws Exception {
+ MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION, GlobalPermissions.DRY_RUN_EXECUTION);
+ String projectKey = "org.codehaus.sonar:sonar";
+ String moduleKey = "org.codehaus.sonar:sonar-server";
+
+ when(componentDao.findModulesByProject(projectKey, session)).thenReturn(newArrayList(
+ new ComponentDto().setKey(projectKey),
+ new ComponentDto().setKey(moduleKey)
+ ));
+
+ when(propertiesDao.selectProjectProperties(projectKey, session)).thenReturn(newArrayList(
+ new PropertyDto().setKey("sonar.jira.project.key").setValue("SONAR"),
+ new PropertyDto().setKey("sonar.jira.login.secured").setValue("john")
+ ));
+ // No property on module
+
+ WsTester.TestRequest request = tester.newGetRequest("batch", "project").setParam("key", projectKey);
+ request.execute().assertJson(getClass(), "return_settings_by_modules_without_empty_module_settings.json");
+ }
+
+ @Test
+ public void return_quality_profiles() throws Exception {
+ MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION, GlobalPermissions.DRY_RUN_EXECUTION);
+
+ String projectKey = "org.codehaus.sonar:sonar";
+
+ when(qProfileFactory.getByProjectAndLanguage(session, projectKey, "java")).thenReturn(
+ QualityProfileDto.createFor("abcd").setName("Default").setLanguage("java").setRulesUpdatedAt("2014-01-14T14:00:00+0200")
+ );
+
+ WsTester.TestRequest request = tester.newGetRequest("batch", "project").setParam("key", projectKey);
+ request.execute().assertJson(getClass(), "return_quality_profiles.json");
+ }
+
+ @Test
+ public void return_quality_profile_from_default_profile() throws Exception {
+ MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION, GlobalPermissions.DRY_RUN_EXECUTION);
+
+ String projectKey = "org.codehaus.sonar:sonar";
+
+ when(qProfileFactory.getDefault(session, "java")).thenReturn(
+ QualityProfileDto.createFor("abcd").setName("Default").setLanguage("java").setRulesUpdatedAt("2014-01-14T14:00:00+0200")
+ );
+
+ WsTester.TestRequest request = tester.newGetRequest("batch", "project").setParam("key", projectKey);
+ request.execute().assertJson(getClass(), "return_quality_profile_from_default_profile.json");
+ }
+
+}
import org.sonar.core.persistence.DbSession;
import java.util.Date;
+import java.util.List;
import static org.fest.assertions.Assertions.assertThat;
import static org.mockito.Mockito.mock;
assertThat(dao.existsById(111L, session)).isFalse();
}
+ @Test
+ public void find_modules_by_project() throws Exception {
+ setupData("shared");
+
+ List<ComponentDto> results = dao.findModulesByProject("org.struts:struts", session);
+ assertThat(results).hasSize(1);
+ assertThat(results.get(0).getKey()).isEqualTo("org.struts:struts-core");
+
+ assertThat(dao.findModulesByProject("unknown", session)).isEmpty();
+ }
+
@Test
public void insert() {
when(system2.now()).thenReturn(DateUtils.parseDate("2014-06-18").getTime());
import org.junit.ClassRule;
import org.junit.Test;
import org.sonar.api.server.rule.RuleParamType;
+import org.sonar.core.component.ComponentDto;
+import org.sonar.core.permission.GlobalPermissions;
import org.sonar.core.persistence.DbSession;
import org.sonar.core.properties.PropertyDto;
import org.sonar.core.qualityprofile.db.QualityProfileDto;
import org.sonar.server.rule.RuleTesting;
import org.sonar.server.search.IndexClient;
import org.sonar.server.tester.ServerTester;
+import org.sonar.server.user.MockUserSession;
import static org.fest.assertions.Assertions.assertThat;
import static org.fest.assertions.Fail.fail;
}
}
+ @Test
+ public void get_profile_by_project_and_language() {
+ ComponentDto project = new ComponentDto()
+ .setId(1L)
+ .setKey("org.codehaus.sonar:sonar")
+ .setName("SonarQube")
+ .setLongName("SonarQube")
+ .setQualifier("TRK")
+ .setScope("TRK")
+ .setEnabled(true);
+ db.componentDao().insert(dbSession, project);
+
+ QualityProfileDto profileDto = QProfileTesting.newXooP1();
+ db.qualityProfileDao().insert(dbSession, profileDto);
+ dbSession.commit();
+ dbSession.clearCache();
+ assertThat(factory.getByProjectAndLanguage("org.codehaus.sonar:sonar", "xoo")).isNull();
+
+ tester.get(QProfileProjectOperations.class).addProject(profileDto.getId(), project.getId(),
+ MockUserSession.set().setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN), dbSession);
+ dbSession.commit();
+ dbSession.clearCache();
+ assertThat(factory.getByProjectAndLanguage("org.codehaus.sonar:sonar", "xoo").getKey()).isEqualTo(XOO_P1_KEY);
+ }
+
private void initRules() {
// create pre-defined rules
RuleDto xooRule1 = RuleTesting.newXooX1();
--- /dev/null
+{
+ "timestamp": 0,
+ "qprofilesByLanguage": {
+ "java": {
+ "key": "abcd",
+ "name": "Default",
+ "language": "java",
+ "rulesUpdatedAt": "Jan 14, 2014 1:00:00 PM"
+ }
+ },
+ "activeRules": [],
+ "settingsByModule": {}
+}
--- /dev/null
+{
+ "timestamp": 0,
+ "qprofilesByLanguage": {
+ "java": {
+ "key": "abcd",
+ "name": "Default",
+ "language": "java",
+ "rulesUpdatedAt": "Jan 14, 2014 1:00:00 PM"
+ }
+ },
+ "activeRules": [],
+ "settingsByModule": {}
+}
--- /dev/null
+{
+ "timestamp": 0,
+ "qprofilesByLanguage": {},
+ "activeRules": [],
+ "settingsByModule": {
+ "org.codehaus.sonar:sonar": {
+ "sonar.jira.project.key": "SONAR",
+ "sonar.jira.login.secured": "john"
+ },
+ "org.codehaus.sonar:sonar-server": {
+ "sonar.coverage.exclusions": "**/*.java"
+ }
+ }
+}
--- /dev/null
+{
+ "timestamp": 0,
+ "qprofilesByLanguage": {},
+ "activeRules": [],
+ "settingsByModule": {
+ "org.codehaus.sonar:sonar": {
+ "sonar.jira.project.key": "SONAR",
+ "sonar.jira.login.secured": "john"
+ }
+ }
+}
*/
package org.sonar.core.component.db;
+import org.apache.ibatis.annotations.Param;
import org.sonar.core.component.ComponentDto;
+import java.util.List;
+
/**
* @since 4.3
*/
ComponentDto selectById(long id);
+ List<ComponentDto> findModulesByProject(@Param("projectKey") String projectKey);
+
long countById(long id);
void insert(ComponentDto rule);
}
}
+ public List<PropertyDto> selectProjectProperties(String resourceKey, SqlSession session) {
+ return session.getMapper(PropertiesMapper.class).selectProjectProperties(resourceKey);
+ }
+
public List<PropertyDto> selectProjectProperties(String resourceKey) {
SqlSession session = mybatis.openSession(false);
- PropertiesMapper mapper = session.getMapper(PropertiesMapper.class);
try {
- return mapper.selectProjectProperties(resourceKey);
+ return selectProjectProperties(resourceKey, session);
} finally {
MyBatis.closeQuietly(session);
}
public QualityProfileDto getByProjectAndLanguage(long projectId, String language, String key) {
DbSession session = mybatis.openSession(false);
try {
- return session.getMapper(QualityProfileMapper.class).selectByProjectAndLanguage(projectId, language, key);
+ return session.getMapper(QualityProfileMapper.class).selectByProjectIdAndLanguage(projectId, language, key);
} finally {
MyBatis.closeQuietly(session);
}
}
+ @CheckForNull
+ public QualityProfileDto getByProjectAndLanguage(String projectKey, String language, String propertyKeyPrefix, DbSession session) {
+ return session.getMapper(QualityProfileMapper.class).selectByProjectAndLanguage(projectKey, language, propertyKeyPrefix);
+ }
+
public List<QualityProfileDto> findByLanguage(String language) {
DbSession session = mybatis.openSession(false);
try {
int countProjects(@Param("value") String propertyValue, @Param("key") String propertyKey);
- QualityProfileDto selectByProjectAndLanguage(@Param("projectId") Long projectId, @Param("language") String language, @Param("key") String propertyKeyPrefix);
+ QualityProfileDto selectByProjectIdAndLanguage(@Param("projectId") Long projectId, @Param("language") String language, @Param("key") String propertyKeyPrefix);
+
+ QualityProfileDto selectByProjectAndLanguage(@Param("projectKey") String projectKey, @Param("language") String language, @Param("propertyKey") String propertyKeyPrefix);
}
<select id="selectByKey" parameterType="String" resultType="Component">
SELECT <include refid="componentColumns"/>
FROM projects p
- INNER JOIN snapshots s on s.project_id=p.id and s.islast=${_true}
- WHERE p.enabled=${_true} AND p.kee=#{key}
+ INNER JOIN snapshots s ON s.project_id=p.id AND s.islast=${_true}
+ <where>
+ AND p.enabled=${_true}
+ AND p.kee=#{key}
+ </where>
</select>
<select id="selectById" parameterType="long" resultType="Component">
SELECT <include refid="componentColumns"/>
FROM projects p
- INNER JOIN snapshots s on s.project_id=p.id and s.islast=${_true}
- WHERE p.enabled=${_true} AND p.id=#{id}
+ INNER JOIN snapshots s ON s.project_id=p.id AND s.islast=${_true}
+ <where>
+ AND p.enabled=${_true}
+ AND p.id=#{id}
+ </where>
</select>
<select id="countById" parameterType="long" resultType="long">
SELECT count(p.id)
FROM projects p
- WHERE p.enabled=${_true} AND p.id=#{id}
+ <where>
+ AND p.enabled=${_true}
+ AND p.id=#{id}
+ </where>
+ </select>
+
+ <select id="findModulesByProject" parameterType="String" resultType="Component">
+ SELECT <include refid="componentColumns"/>
+ FROM projects p
+ INNER JOIN projects root ON root.id=p.root_id AND root.enabled=${_true} AND root.kee=#{projectKey}
+ INNER JOIN snapshots s ON s.project_id=p.id AND s.islast=${_true}
+ <where>
+ AND p.enabled=${_true}
+ AND p.scope='PRJ'
+ </where>
</select>
<sql id="insertColumns">
</where>
</select>
- <select id="selectByProjectAndLanguage" parameterType="map" resultType="QualityProfile">
+ <select id="selectByProjectIdAndLanguage" parameterType="map" resultType="QualityProfile">
SELECT <include refid="profilesColumns"/>
FROM rules_profiles p
INNER JOIN properties prop ON prop.resource_id=#{projectId}
WHERE p.language=#{language}
</select>
+ <select id="selectByProjectAndLanguage" parameterType="map" resultType="QualityProfile">
+ SELECT <include refid="profilesColumns"/>
+ FROM rules_profiles p, projects project
+ INNER JOIN properties prop ON prop.resource_id=project.id
+ <where>
+ AND p.language=#{language}
+ AND prop.prop_key LIKE #{propertyKey}
+ AND prop.text_value LIKE p.name
+ AND project.kee=#{projectKey}
+ </where>
+ </select>
+
</mapper>
package org.sonar.core.qualityprofile.db;
+import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.sonar.api.utils.System2;
public class QualityProfileDaoTest extends AbstractDaoTestCase {
QualityProfileDao dao;
+ DbSession session;
System2 system = mock(System2.class);
@Before
public void createDao() {
+ this.session = getMyBatis().openSession(false);
dao = new QualityProfileDao(getMyBatis(), system);
when(system.now()).thenReturn(UtcDateUtils.parseDateTime("2014-01-20T12:00:00+0000").getTime());
}
+ @After
+ public void after() {
+ this.session.close();
+ }
+
@Test
public void insert() {
setupData("shared");
}
@Test
- public void select_by_project_and_language() {
+ public void select_by_project_id_and_language() {
setupData("projects");
QualityProfileDto dto = dao.getByProjectAndLanguage(1L, "java", "sonar.profile.java");
assertThat(dto.getId()).isEqualTo(1);
}
+
+ @Test
+ public void select_by_project_key_and_language() {
+ setupData("projects");
+
+ QualityProfileDto dto = dao.getByProjectAndLanguage("org.codehaus.sonar:sonar", "java", "sonar.profile.java", session);
+ assertThat(dto.getId()).isEqualTo(1);
+
+ assertThat(dao.getByProjectAndLanguage("org.codehaus.sonar:sonar", "unkown", "sonar.profile.java", session)).isNull();
+ assertThat(dao.getByProjectAndLanguage("unknown", "java", "sonar.profile.java", session)).isNull();
+ }
}
projects / sonarqube.git / commitdiff