response.stream().setMediaType(MimeTypes.PROTOBUF);
DbSession session = dbClient.openSession(false);
try {
- ComponentDto component = dbClient.componentDao().getByKey(session, moduleKey);
+ ComponentDto component = dbClient.componentDao().selectByKey(session, moduleKey);
Map<String, String> keysByUUid = keysByUUid(session, component);
BatchInput.ServerIssue.Builder issueBuilder = BatchInput.ServerIssue.newBuilder();
try {
ProjectRepositories ref = new ProjectRepositories();
String projectKey = query.getModuleKey();
- ComponentDto module = dbClient.componentDao().getNullableByKey(session, query.getModuleKey());
+ ComponentDto module = dbClient.componentDao().selectNullableByKey(session, query.getModuleKey());
// Current project/module can be null when analysing a new project
if (module != null) {
// Scan permission is enough to analyze all projects but preview permission is limited to projects user can access
public void delete(String projectKey) {
DbSession dbSession = dbClient.openSession(false);
try {
- ComponentDto project = dbClient.componentDao().getByKey(dbSession, projectKey);
+ ComponentDto project = dbClient.componentDao().selectByKey(dbSession, projectKey);
if (!Scopes.PROJECT.equals(project.scope())) {
throw new IllegalArgumentException("Only projects can be deleted");
}
import com.google.common.base.Joiner;
import com.google.common.collect.Collections2;
import com.google.common.collect.Sets;
-import java.util.Collection;
-import java.util.Date;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-import java.util.Set;
-import javax.annotation.CheckForNull;
-import javax.annotation.Nullable;
import org.sonar.api.ServerSide;
import org.sonar.api.i18n.I18n;
import org.sonar.api.resources.Scopes;
+import org.sonar.api.utils.System2;
import org.sonar.api.utils.internal.Uuids;
import org.sonar.api.web.UserRole;
import org.sonar.core.component.ComponentDto;
import org.sonar.server.permission.InternalPermissionService;
import org.sonar.server.user.UserSession;
+import javax.annotation.CheckForNull;
+import javax.annotation.Nullable;
+
+import java.util.Collection;
+import java.util.Date;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+
import static com.google.common.collect.Lists.newArrayList;
@ServerSide
private final ResourceIndexerDao resourceIndexerDao;
private final InternalPermissionService permissionService;
private final UserSession userSession;
+ private final System2 system2;
public ComponentService(DbClient dbClient, ResourceKeyUpdaterDao resourceKeyUpdaterDao, I18n i18n, ResourceIndexerDao resourceIndexerDao,
- InternalPermissionService permissionService, UserSession userSession) {
+ InternalPermissionService permissionService, UserSession userSession, System2 system2) {
this.dbClient = dbClient;
this.resourceKeyUpdaterDao = resourceKeyUpdaterDao;
this.i18n = i18n;
this.resourceIndexerDao = resourceIndexerDao;
this.permissionService = permissionService;
this.userSession = userSession;
+ this.system2 = system2;
}
public ComponentDto getByKey(String key) {
}
String uuid = Uuids.create();
- ComponentDto component = dbClient.componentDao().insert(session,
- new ComponentDto()
+ ComponentDto component = new ComponentDto()
.setUuid(uuid)
.setModuleUuid(null)
.setModuleUuidPath(ComponentDto.MODULE_UUID_PATH_SEP + uuid + ComponentDto.MODULE_UUID_PATH_SEP)
.setLongName(newComponent.name())
.setScope(Scopes.PROJECT)
.setQualifier(newComponent.qualifier())
- .setCreatedAt(new Date()));
+ .setCreatedAt(new Date(system2.now()))
+ ;
+ dbClient.componentDao().insert(session, component);
resourceIndexerDao.indexResource(session, component.getId());
session.commit();
public Collection<String> componentUuids(DbSession session, @Nullable Collection<String> componentKeys, boolean ignoreMissingComponents) {
Collection<String> componentUuids = newArrayList();
if (componentKeys != null && !componentKeys.isEmpty()) {
- List<ComponentDto> components = dbClient.componentDao().getByKeys(session, componentKeys);
+ List<ComponentDto> components = dbClient.componentDao().selectByKeys(session, componentKeys);
if (!ignoreMissingComponents && components.size() < componentKeys.size()) {
Collection<String> foundKeys = Collections2.transform(components, new Function<ComponentDto, String>() {
@CheckForNull
private ComponentDto getNullableByKey(DbSession session, String key) {
- return dbClient.componentDao().getNullableByKey(session, key);
+ return dbClient.componentDao().selectNullableByKey(session, key);
}
private ComponentDto getByKey(DbSession session, String key) {
- return dbClient.componentDao().getByKey(session, key);
+ return dbClient.componentDao().selectByKey(session, key);
}
}
package org.sonar.server.component.db;
import com.google.common.base.Function;
+import com.google.common.collect.Lists;
import org.apache.ibatis.session.RowBounds;
import org.sonar.api.ServerSide;
import org.sonar.api.resources.Qualifiers;
import org.sonar.api.resources.Scopes;
-import org.sonar.api.utils.System2;
import org.sonar.core.component.ComponentDto;
import org.sonar.core.component.FilePathWithHashDto;
import org.sonar.core.component.UuidWithProjectUuidDto;
import org.sonar.core.persistence.DaoComponent;
import org.sonar.core.persistence.DaoUtils;
import org.sonar.core.persistence.DbSession;
-import org.sonar.server.db.BaseDao;
import org.sonar.server.es.SearchOptions;
import org.sonar.server.exceptions.NotFoundException;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
+
import java.util.Collection;
import java.util.Collections;
import java.util.List;
* @since 4.3
*/
@ServerSide
-public class ComponentDao extends BaseDao<ComponentMapper, ComponentDto, String> implements DaoComponent {
-
- public ComponentDao(System2 system) {
- super(ComponentMapper.class, system);
- }
+public class ComponentDao implements DaoComponent {
public ComponentDto getById(Long id, DbSession session) {
ComponentDto componentDto = getNullableById(id, session);
});
}
- @Override
- protected List<ComponentDto> doGetByKeys(DbSession session, Collection<String> keys) {
+ public List<ComponentDto> selectByKeys(DbSession session, Collection<String> keys) {
return mapper(session).findByKeys(keys);
}
- @Override
+ public ComponentDto selectByKey(DbSession session, String key) {
+ ComponentDto value = selectNullableByKey(session, key);
+ if (value == null) {
+ throw new NotFoundException(String.format("Component key '%s' not found", key));
+ }
+ return mapper(session).selectByKey(key);
+ }
+
@CheckForNull
- protected ComponentDto doGetNullableByKey(DbSession session, String key) {
+ public ComponentDto selectNullableByKey(DbSession session, String key) {
return mapper(session).selectByKey(key);
}
- @Override
- protected ComponentDto doInsert(DbSession session, ComponentDto item) {
+ public void insert(DbSession session, ComponentDto item) {
mapper(session).insert(item);
- return item;
}
- @Override
- protected void doDeleteByKey(DbSession session, String key) {
- mapper(session).deleteByKey(key);
+ public void insert(DbSession session, Collection<ComponentDto> items) {
+ for (ComponentDto item : items) {
+ insert(session, item);
+ }
+ }
+
+ public void insert(DbSession session, ComponentDto item, ComponentDto... others) {
+ insert(session, Lists.asList(item, others));
}
public List<String> findProjectUuids(DbSession session) {
private void addProjectQualifier(Map<String, String> parameters) {
parameters.put("qualifier", Qualifiers.PROJECT);
}
+
+ private ComponentMapper mapper(DbSession session) {
+ return session.getMapper(ComponentMapper.class);
+ }
}
private ComponentDto loadProject(ReportQueue.Item item) {
DbSession session = dbClient.openSession(false);
try {
- return dbClient.componentDao().getByKey(session, item.dto.getProjectKey());
+ return dbClient.componentDao().selectByKey(session, item.dto.getProjectKey());
} finally {
MyBatis.closeQuietly(session);
}
}
private void checkThatProjectExistsInDatabase(String projectKey, DbSession session) {
- dbClient.componentDao().getByKey(session, projectKey);
+ dbClient.componentDao().selectByKey(session, projectKey);
}
public void remove(Item item) {
for (Map.Entry<String, String> entry : refByComponentKey.entrySet()) {
String componentKey = entry.getKey();
String ref = entry.getValue();
- ComponentDto file = componentDao.getNullableByKey(session, componentKey);
+ ComponentDto file = componentDao.selectNullableByKey(session, componentKey);
if (file != null) {
json.name(ref).beginObject();
private Duplication createDuplication(Map<String, ComponentDto> componentsByKey, String from, String size, String componentKey, DbSession session) {
ComponentDto component = componentsByKey.get(componentKey);
if (component == null) {
- component = componentDao.getNullableByKey(session, componentKey);
+ component = componentDao.selectNullableByKey(session, componentKey);
componentsByKey.put(componentKey, component);
}
return new Duplication(component, Integer.valueOf(from), Integer.valueOf(size));
import com.google.common.base.Preconditions;
import com.google.common.io.Resources;
-import java.util.List;
-import javax.annotation.CheckForNull;
import org.sonar.api.measures.CoreMetrics;
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.RequestHandler;
import org.sonar.server.measure.persistence.MeasureDao;
import org.sonar.server.user.UserSession;
+import javax.annotation.CheckForNull;
+
+import java.util.List;
+
public class ShowAction implements RequestHandler {
private final DbClient dbClient;
}
private ComponentDto findComponent(String key, DbSession session) {
- ComponentDto componentDto = componentDao.getNullableByKey(session, key);
+ ComponentDto componentDto = componentDao.selectNullableByKey(session, key);
if (componentDto == null) {
throw new NotFoundException(String.format("Component with key '%s' not found", key));
}
}
IssueChangeContext changeContext = IssueChangeContext.createUser(new Date(), userSession.getLogin());
- Component project = dbClient.componentDao().getByKey(session, issue.projectKey());
+ Component project = dbClient.componentDao().selectByKey(session, issue.projectKey());
FunctionContext functionContext = new FunctionContext(issue, updater, changeContext, getProjectSettings(project));
for (Function function : action.functions()) {
function.execute(functionContext);
rules.put(rule.ruleKey(), rule);
}
- for (ComponentDto file : dbClient.componentDao().getByKeys(session, componentKeys)) {
+ for (ComponentDto file : dbClient.componentDao().selectByKeys(session, componentKeys)) {
components.put(file.getKey(), file);
}
- for (ComponentDto project : dbClient.componentDao().getByKeys(session, projectKeys)) {
+ for (ComponentDto project : dbClient.componentDao().selectByKeys(session, projectKeys)) {
projects.put(project.getKey(), project);
}
} finally {
*/
package org.sonar.server.issue;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Date;
-import java.util.List;
-import java.util.Map;
-
-import javax.annotation.CheckForNull;
-import javax.annotation.Nullable;
-
+import com.google.common.base.Objects;
+import com.google.common.base.Strings;
import org.apache.commons.lang.StringUtils;
import org.sonar.api.ServerSide;
import org.sonar.api.issue.ActionPlan;
import org.sonar.server.user.index.UserDoc;
import org.sonar.server.user.index.UserIndex;
-import com.google.common.base.Objects;
-import com.google.common.base.Strings;
+import javax.annotation.CheckForNull;
+import javax.annotation.Nullable;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
@ServerSide
public class IssueService {
DbSession session = dbClient.openSession(false);
try {
- ComponentDto component = dbClient.componentDao().getByKey(session, componentKey);
+ ComponentDto component = dbClient.componentDao().selectByKey(session, componentKey);
ComponentDto project = dbClient.componentDao().getByUuid(session, component.projectUuid());
userSession.checkProjectPermission(UserRole.USER, project.getKey());
.setIssue(issue)
.setChangeAuthorLogin(context.login())
.setRuleName(rule != null ? rule.getName() : null)
- .setProject(dbClient.componentDao().getByKey(session, projectKey))
- .setComponent(dbClient.componentDao().getNullableByKey(session, issue.componentKey()))
+ .setProject(dbClient.componentDao().selectByKey(session, projectKey))
+ .setComponent(dbClient.componentDao().selectNullableByKey(session, issue.componentKey()))
.setComment(comment));
}
}
protected ComponentDto component(DbSession session, DefaultIssue issue) {
- return dbClient.componentDao().getByKey(session, issue.componentKey());
+ return dbClient.componentDao().selectByKey(session, issue.componentKey());
}
protected ComponentDto project(DbSession session, DefaultIssue issue) {
- return dbClient.componentDao().getByKey(session, issue.projectKey());
+ return dbClient.componentDao().selectByKey(session, issue.projectKey());
}
}
package org.sonar.server.permission;
-import java.util.List;
-import java.util.Map;
-
-import javax.annotation.CheckForNull;
-import javax.annotation.Nullable;
-
import org.sonar.api.ServerSide;
import org.sonar.api.security.DefaultGroups;
import org.sonar.api.web.UserRole;
import org.sonar.server.issue.index.IssueAuthorizationIndexer;
import org.sonar.server.user.UserSession;
+import javax.annotation.CheckForNull;
+import javax.annotation.Nullable;
+
+import java.util.List;
+import java.util.Map;
+
/**
* Used by ruby code <pre>Internal.permissions</pre>
*/
DbSession session = dbClient.openSession(false);
try {
- ComponentDto component = dbClient.componentDao().getByKey(session, componentKey);
+ ComponentDto component = dbClient.componentDao().selectByKey(session, componentKey);
ResourceDto provisioned = dbClient.resourceDao().selectProvisionedProject(session, componentKey);
if (provisioned == null) {
checkProjectAdminPermission(componentKey);
}
for (String componentKey : query.getSelectedComponents()) {
- ComponentDto component = dbClient.componentDao().getByKey(session, componentKey);
+ ComponentDto component = dbClient.componentDao().selectByKey(session, componentKey);
permissionFacade.applyPermissionTemplate(session, query.getTemplateKey(), component.getId());
projectsChanged = true;
}
if (componentKey == null) {
return null;
} else {
- ComponentDto component = dbClient.componentDao().getByKey(session, componentKey);
+ ComponentDto component = dbClient.componentDao().selectByKey(session, componentKey);
return component.getId();
}
}
public void handle(Request request, Response response) throws Exception {
try (DbSession session = dbClient.openSession(false)) {
final String componentKey = request.mandatoryParam("key");
- final ComponentDto component = dbClient.componentDao().getByKey(session, componentKey);
+ final ComponentDto component = dbClient.componentDao().selectByKey(session, componentKey);
userSession.checkProjectUuidPermission(UserRole.USER, component.projectUuid());
response.stream().setMediaType("text/plain");
package org.sonar.server.source.ws;
import com.google.common.io.Resources;
-import java.util.List;
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.Response;
import org.sonar.api.server.ws.WebService;
import org.sonar.server.source.SourceService;
import org.sonar.server.user.UserSession;
+import java.util.List;
+
public class IndexAction implements SourcesWsAction {
private final DbClient dbClient;
Integer from = request.mandatoryParamAsInt("from");
Integer to = request.paramAsInt("to");
try (DbSession session = dbClient.openSession(false)) {
- ComponentDto componentDto = dbClient.componentDao().getByKey(session, fileKey);
+ ComponentDto componentDto = dbClient.componentDao().selectByKey(session, fileKey);
List<String> lines = sourceService.getLinesAsTxt(componentDto.uuid(), from, to == null ? null : to - 1);
JsonWriter json = response.newJsonWriter().beginArray().beginObject();
Integer lineCounter = from;
package org.sonar.server.source.ws;
import com.google.common.io.Resources;
-import java.util.Date;
-import java.util.List;
import org.apache.commons.lang.ObjectUtils;
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.Response;
import org.sonar.server.source.index.SourceLineIndex;
import org.sonar.server.user.UserSession;
+import java.util.Date;
+import java.util.List;
+
public class LinesAction implements SourcesWsAction {
private static final String PARAM_UUID = "uuid";
}
String fileKey = request.param(PARAM_KEY);
if (fileKey != null) {
- return dbClient.componentDao().getByKey(session, fileKey);
+ return dbClient.componentDao().selectByKey(session, fileKey);
}
throw new IllegalArgumentException(String.format("Param %s or param %s is missing", PARAM_UUID, PARAM_KEY));
} finally {
String fileKey = request.mandatoryParam("key");
userSession.checkComponentPermission(UserRole.CODEVIEWER, fileKey);
try (DbSession session = dbClient.openSession(false)) {
- ComponentDto componentDto = dbClient.componentDao().getByKey(session, fileKey);
+ ComponentDto componentDto = dbClient.componentDao().selectByKey(session, fileKey);
List<String> lines = sourceService.getLinesAsTxt(componentDto.uuid(), null, null);
response.stream().setMediaType("text/plain");
IOUtils.writeLines(lines, "\n", response.stream().output(), StandardCharsets.UTF_8);
import com.google.common.base.Strings;
import com.google.common.io.Resources;
-import java.util.Date;
-import java.util.List;
import org.apache.commons.lang.ObjectUtils;
import org.apache.commons.lang.builder.EqualsBuilder;
import org.sonar.api.server.ws.Request;
import org.sonar.server.source.index.SourceLineIndex;
import org.sonar.server.user.UserSession;
+import java.util.Date;
+import java.util.List;
+
public class ScmAction implements SourcesWsAction {
private final DbClient dbClient;
DbSession session = dbClient.openSession(false);
try {
- ComponentDto fileDto = dbClient.componentDao().getByKey(session, fileKey);
+ ComponentDto fileDto = dbClient.componentDao().selectByKey(session, fileKey);
userSession.checkProjectUuidPermission(UserRole.CODEVIEWER, fileDto.projectUuid());
List<SourceLineDoc> sourceLines = sourceLineIndex.getLines(fileDto.uuid(), from, to);
if (sourceLines.isEmpty()) {
package org.sonar.server.source.ws;
import com.google.common.io.Resources;
-import java.util.List;
import org.apache.commons.lang.ObjectUtils;
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.Response;
import org.sonar.server.source.SourceService;
import org.sonar.server.user.UserSession;
+import java.util.List;
+
public class ShowAction implements SourcesWsAction {
private final SourceService sourceService;
DbSession session = dbClient.openSession(false);
try {
- ComponentDto componentDto = dbClient.componentDao().getByKey(session, fileKey);
+ ComponentDto componentDto = dbClient.componentDao().selectByKey(session, fileKey);
List<String> linesHtml = sourceService.getLinesAsHtml(componentDto.uuid(), from, to);
JsonWriter json = response.newJsonWriter().beginObject();
writeSource(linesHtml, from, json);
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.io.Resources;
-import java.util.List;
-import java.util.Map;
-import javax.annotation.Nullable;
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.Response;
import org.sonar.api.server.ws.WebService;
import org.sonar.server.test.index.TestIndex;
import org.sonar.server.user.UserSession;
+import javax.annotation.Nullable;
+
+import java.util.List;
+import java.util.Map;
+
public class TestsListAction implements TestsWsAction {
public static final String TEST_UUID = "testUuid";
public static final String TEST_FILE_UUID = "testFileUuid";
private SearchResult<TestDoc> searchTestsByTestFileKey(DbSession dbSession, String testFileKey, SearchOptions searchOptions) {
userSession.checkComponentPermission(UserRole.CODEVIEWER, testFileKey);
- ComponentDto testFile = dbClient.componentDao().getByKey(dbSession, testFileKey);
+ ComponentDto testFile = dbClient.componentDao().selectByKey(dbSession, testFileKey);
return testIndex.searchByTestFileUuid(testFile.uuid(), searchOptions);
}
DbSession session = dbClient.openSession(false);
try {
- ComponentDto component = dbClient.componentDao().getByKey(session, componentKey);
+ ComponentDto component = dbClient.componentDao().selectByKey(session, componentKey);
userSession.checkProjectUuidPermission(UserRole.USER, component.projectUuid());
es.truncateIndices();
this.session = db.myBatis().openSession(false);
- componentDao = new ComponentDao(mock(System2.class));
+ componentDao = new ComponentDao();
DbClient dbClient = new DbClient(db.database(), db.myBatis(), new IssueDao(db.myBatis()), componentDao);
issueIndex = new IssueIndex(es.client(), System2.INSTANCE, userSessionRule);
issueIndexer = new IssueIndexer(null, es.client());
service.delete(project.getKey());
- assertThat(db.componentDao().getNullableByKey(session, project.key())).isNull();
+ assertThat(db.componentDao().selectNullableByKey(session, project.key())).isNull();
}
@Test
package org.sonar.server.component.db;
-import org.apache.ibatis.exceptions.PersistenceException;
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
+import org.junit.rules.ExpectedException;
import org.sonar.api.utils.DateUtils;
-import org.sonar.api.utils.System2;
import org.sonar.core.component.ComponentDto;
import org.sonar.core.component.FilePathWithHashDto;
import org.sonar.core.persistence.DbSession;
import org.sonar.server.exceptions.NotFoundException;
import java.util.Collections;
-import java.util.Date;
import java.util.List;
import static com.google.common.collect.Lists.newArrayList;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
public class ComponentDaoTest {
+ @Rule
+ public ExpectedException thrown = ExpectedException.none();
+
ComponentDao sut;
@ClassRule
public static DbTester db = new DbTester();
DbSession session;
- System2 system2;
-
@Before
public void createDao() {
session = db.myBatis().openSession(false);
- system2 = mock(System2.class);
- sut = new ComponentDao(system2);
+ sut = new ComponentDao();
}
@After
assertThat(result.isEnabled()).isFalse();
}
- @Test(expected = NotFoundException.class)
+ @Test
public void fail_to_get_by_uuid_when_component_not_found() {
+ thrown.expect(NotFoundException.class);
+
loadBasicDataInDatabase();
sut.getByUuid(session, "unknown");
public void get_by_key() {
loadBasicDataInDatabase();
- ComponentDto result = sut.getNullableByKey(session, "org.struts:struts-core:src/org/struts/RequestContext.java");
+ ComponentDto result = sut.selectNullableByKey(session, "org.struts:struts-core:src/org/struts/RequestContext.java");
assertThat(result).isNotNull();
assertThat(result.key()).isEqualTo("org.struts:struts-core:src/org/struts/RequestContext.java");
assertThat(result.path()).isEqualTo("src/org/struts/RequestContext.java");
assertThat(result.language()).isEqualTo("java");
assertThat(result.parentProjectId()).isEqualTo(2);
- assertThat(sut.getNullableByKey(session, "unknown")).isNull();
+ assertThat(sut.selectNullableByKey(session, "unknown")).isNull();
+ }
+
+ @Test
+ public void fail_to_get_by_key_when_component_not_found() {
+ thrown.expect(NotFoundException.class);
+
+ loadBasicDataInDatabase();
+
+ sut.getByUuid(session, "unknown");
}
@Test
public void get_by_key_on_disabled_component() {
loadBasicDataInDatabase();
- ComponentDto result = sut.getNullableByKey(session, "org.disabled.project");
+ ComponentDto result = sut.selectByKey(session, "org.disabled.project");
assertThat(result).isNotNull();
assertThat(result.isEnabled()).isFalse();
}
public void get_by_key_on_a_root_project() {
loadBasicDataInDatabase();
- ComponentDto result = sut.getNullableByKey(session, "org.struts:struts");
+ ComponentDto result = sut.selectByKey(session, "org.struts:struts");
assertThat(result).isNotNull();
assertThat(result.key()).isEqualTo("org.struts:struts");
assertThat(result.deprecatedKey()).isEqualTo("org.struts:struts");
public void get_by_keys() {
loadBasicDataInDatabase();
- List<ComponentDto> results = sut.getByKeys(session, "org.struts:struts-core:src/org/struts/RequestContext.java");
+ List<ComponentDto> results = sut.selectByKeys(session, Collections.singletonList("org.struts:struts-core:src/org/struts/RequestContext.java"));
assertThat(results).hasSize(1);
ComponentDto result = results.get(0);
assertThat(result.language()).isEqualTo("java");
assertThat(result.parentProjectId()).isEqualTo(2);
- assertThat(sut.getByKeys(session, "unknown")).isEmpty();
+ assertThat(sut.selectByKeys(session, Collections.singletonList("unknown"))).isEmpty();
}
@Test
@Test
public void insert() {
- when(system2.now()).thenReturn(DateUtils.parseDate("2014-06-18").getTime());
db.prepareDbUnit(getClass(), "empty.xml");
ComponentDto componentDto = new ComponentDto()
.setParentProjectId(3L)
.setCopyResourceId(5L)
.setEnabled(true)
+ .setCreatedAt(DateUtils.parseDate("2014-06-18"))
.setAuthorizationUpdatedAt(123456789L);
sut.insert(session, componentDto);
@Test
public void insert_disabled_component() {
- when(system2.now()).thenReturn(DateUtils.parseDate("2014-06-18").getTime());
db.prepareDbUnit(getClass(), "empty.xml");
ComponentDto componentDto = new ComponentDto()
.setPath("src/org/struts/RequestContext.java")
.setParentProjectId(3L)
.setEnabled(false)
+ .setCreatedAt(DateUtils.parseDate("2014-06-18"))
.setAuthorizationUpdatedAt(123456789L);
sut.insert(session, componentDto);
db.assertDbUnit(getClass(), "insert_disabled_component-result.xml", "projects");
}
- @Test(expected = IllegalStateException.class)
- public void update() {
- sut.update(session, new ComponentDto()
- .setId(1L)
- .setKey("org.struts:struts-core:src/org/struts/RequestContext.java")
- );
- }
-
- @Test
- public void delete() {
- loadBasicDataInDatabase();
-
- sut.delete(session, new ComponentDto()
- .setId(1L)
- .setKey("org.struts:struts-core:src/org/struts/RequestContext.java")
- );
- session.commit();
-
- db.assertDbUnit(getClass(), "delete-result.xml", "projects");
- }
-
@Test
public void find_project_uuids() {
db.prepareDbUnit(getClass(), "find_project_uuids.xml");
assertThat(sut.findProjectUuids(session)).containsExactly("ABCD");
}
- @Test(expected = PersistenceException.class)
- public void synchronize_after() {
- sut.synchronizeAfter(session, new Date(0L));
- }
-
@Test
public void select_views_and_sub_views() {
db.prepareDbUnit(getClass(), "shared_views.xml");
@Before
public void setUp() {
- dbClient = new DbClient(db.database(), db.myBatis(), new ComponentDao(System2.INSTANCE), new SnapshotDao(System2.INSTANCE));
+ dbClient = new DbClient(db.database(), db.myBatis(), new ComponentDao(), new SnapshotDao(System2.INSTANCE));
dbSession = dbClient.openSession(false);
ws = new WsTester(new ProjectsWs(new ProjectsGhostsAction(dbClient, userSessionRule)));
db.truncateTables();
.setKey("org.apache.hbas:hbase")
.setName("HBase")
.setCreatedAt(DateUtils.parseDateTime("2015-03-04T23:03:44+0100"));
- hBaseProject = dbClient.componentDao().insert(dbSession, hBaseProject);
+ dbClient.componentDao().insert(dbSession, hBaseProject);
dbClient.snapshotDao().insert(dbSession, SnapshotTesting.createForProject(hBaseProject)
.setStatus(SnapshotDto.STATUS_UNPROCESSED));
ComponentDto roslynProject = ComponentTesting.newProjectDto("c526ef20-131b-4486-9357-063fa64b5079")
.setKey("com.microsoft.roslyn:roslyn")
.setName("Roslyn")
.setCreatedAt(DateUtils.parseDateTime("2013-03-04T23:03:44+0100"));
- roslynProject = dbClient.componentDao().insert(dbSession, roslynProject);
+ dbClient.componentDao().insert(dbSession, roslynProject);
dbClient.snapshotDao().insert(dbSession, SnapshotTesting.createForProject(roslynProject)
.setStatus(SnapshotDto.STATUS_UNPROCESSED));
dbSession.commit();
.newProjectDto("ghost-uuid-" + id)
.setName("ghost-name-" + id)
.setKey("ghost-key-" + id);
- project = dbClient.componentDao().insert(dbSession, project);
+ dbClient.componentDao().insert(dbSession, project);
SnapshotDto snapshot = SnapshotTesting.createForProject(project)
.setStatus(SnapshotDto.STATUS_UNPROCESSED);
dbClient.snapshotDao().insert(dbSession, snapshot);
.newProjectDto("analyzed-uuid-" + id)
.setName("analyzed-name-" + id)
.setKey("analyzed-key-" + id);
- project = dbClient.componentDao().insert(dbSession, project);
+ dbClient.componentDao().insert(dbSession, project);
SnapshotDto snapshot = SnapshotTesting.createForProject(project);
dbClient.snapshotDao().insert(dbSession, snapshot);
dbSession.commit();
@Before
public void setUp() {
- dbClient = new DbClient(db.database(), db.myBatis(), new ComponentDao(system2), new SnapshotDao(System2.INSTANCE));
+ dbClient = new DbClient(db.database(), db.myBatis(), new ComponentDao(), new SnapshotDao(System2.INSTANCE));
dbSession = dbClient.openSession(false);
componentDao = dbClient.componentDao();
db.truncateTables();
public void all_provisioned_projects_without_analyzed_projects() throws Exception {
userSessionRule.setGlobalPermissions(UserRole.ADMIN);
ComponentDto analyzedProject = ComponentTesting.newProjectDto("analyzed-uuid-1");
- componentDao.insert(dbSession, newProvisionedProject("1"), newProvisionedProject("2"));
- analyzedProject = dbClient.componentDao().insert(dbSession, analyzedProject);
+ componentDao.insert(dbSession, newProvisionedProject("1"), newProvisionedProject("2"), analyzedProject);
SnapshotDto snapshot = SnapshotTesting.createForProject(analyzedProject);
dbClient.snapshotDao().insert(dbSession, snapshot);
dbSession.commit();
assertThat(componentDao.countProvisionedProjects(dbSession, "visioned-name-")).isEqualTo(2);
}
- private static ComponentDto newProvisionedProject(String id) {
+ private static ComponentDto newProvisionedProject(String uuid) {
return ComponentTesting
- .newProjectDto("provisioned-uuid-" + id)
- .setName("provisioned-name-" + id)
- .setKey("provisioned-key-" + id);
+ .newProjectDto("provisioned-uuid-" + uuid)
+ .setName("provisioned-name-" + uuid)
+ .setKey("provisioned-key-" + uuid);
}
@Test
import org.junit.Rule;
import org.junit.Test;
import org.junit.experimental.categories.Category;
-import org.sonar.api.utils.System2;
import org.sonar.api.web.UserRole;
import org.sonar.core.persistence.DbTester;
import org.sonar.core.user.AuthorizationDao;
public void setUp() {
dbTester.truncateTables();
DbClient dbClient = new DbClient(dbTester.database(), dbTester.myBatis(),
- new ComponentDao(mock(System2.class)), new AuthorizationDao(dbTester.myBatis()), new ComponentIndexDao()
+ new ComponentDao(), new AuthorizationDao(dbTester.myBatis()), new ComponentIndexDao()
);
tester = new WsTester(new ComponentsWs(mock(ComponentAppAction.class), new SearchAction(dbClient, userSessionRule)));
}
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.fail;
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
public class ComputationServiceTest {
@Before
public void setUp() {
- DbClient dbClient = new DbClient(dbTester.database(), dbTester.myBatis(), new ComponentDao(system), new SnapshotDao(system));
+ DbClient dbClient = new DbClient(dbTester.database(), dbTester.myBatis(), new ComponentDao(), new SnapshotDao(system));
sut = new ComputationService(dbClient, steps, activityService, settingsFactory, tempFolder, system);
// db contains project with key "P1"
settings.setProperty(ProcessProperties.PATH_DATA, dataDir.getAbsolutePath());
when(system.now()).thenReturn(NOW);
- DbClient dbClient = new DbClient(db.database(), db.myBatis(), new ComponentDao(system), new AnalysisReportDao(system));
+ DbClient dbClient = new DbClient(db.database(), db.myBatis(), new ComponentDao(), new AnalysisReportDao(system));
sut = new ReportQueue(dbClient, settings);
try (DbSession session = dbClient.openSession(false)) {
package org.sonar.server.computation.step;
-import org.junit.*;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.ClassRule;
+import org.junit.Rule;
+import org.junit.Test;
import org.sonar.api.config.Settings;
import org.sonar.api.resources.Qualifiers;
-import org.sonar.api.utils.System2;
import org.sonar.core.component.ComponentDto;
import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.DbTester;
public void setUp() {
esTester.truncateIndices();
session = db.myBatis().openSession(false);
- dbClient = new DbClient(db.database(), db.myBatis(), new IssueDao(db.myBatis()), new ComponentDao(mock(System2.class)));
+ dbClient = new DbClient(db.database(), db.myBatis(), new IssueDao(db.myBatis()), new ComponentDao());
sut = new PurgeRemovedViewsStep(new ViewIndex(esTester.client()), dbClient);
}
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.failBecauseExceptionWasNotThrown;
-import static org.mockito.Mockito.mock;
public class ShowActionTest {
@Before
public void setUp() {
dbTester.truncateTables();
- dbClient = new DbClient(dbTester.database(), dbTester.myBatis(), new ComponentDao(mock(System2.class)), new SnapshotDao(System2.INSTANCE), new FileDependencyDao());
+ dbClient = new DbClient(dbTester.database(), dbTester.myBatis(), new ComponentDao(), new SnapshotDao(System2.INSTANCE), new FileDependencyDao());
session = dbClient.openSession(false);
tester = new WsTester(new DependenciesWs(new ShowAction(dbClient, userSessionRule)));
controller = tester.controller("api/dependencies");
import java.util.List;
import static com.google.common.collect.Lists.newArrayList;
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.anyString;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class DuplicationsJsonWriterTest {
String key2 = "org.codehaus.sonar:sonar-ws-client:src/main/java/org/sonar/wsclient/services/PropertyUpdateQuery.java";
ComponentDto file2 = ComponentTesting.newFileDto(project).setId(11L).setQualifier("FIL").setKey(key2).setLongName("PropertyUpdateQuery").setParentProjectId(5L);
- when(componentDao.getNullableByKey(session, key1)).thenReturn(file1);
- when(componentDao.getNullableByKey(session, key2)).thenReturn(file2);
+ when(componentDao.selectNullableByKey(session, key1)).thenReturn(file1);
+ when(componentDao.selectNullableByKey(session, key2)).thenReturn(file2);
when(componentDao.getNullableById(5L, session)).thenReturn(
new ComponentDto().setId(5L).setKey("org.codehaus.sonar:sonar-ws-client").setLongName("SonarQube :: Web Service Client"));
when(componentDao.getNullableByUuid(session, project.uuid())).thenReturn(project);
" }" +
"}");
- verify(componentDao, times(2)).getNullableByKey(eq(session), anyString());
+ verify(componentDao, times(2)).selectNullableByKey(eq(session), anyString());
// Verify call to dao is cached when searching for project / sub project
verify(componentDao, times(1)).getNullableByUuid(eq(session), eq(project.uuid()));
verify(componentDao, times(1)).getNullableById(eq(5L), eq(session));
String key2 = "org.codehaus.sonar:sonar-ws-client:src/main/java/org/sonar/wsclient/services/PropertyUpdateQuery.java";
ComponentDto file2 = ComponentTesting.newFileDto(project).setId(11L).setKey(key2).setLongName("PropertyUpdateQuery");
- when(componentDao.getNullableByKey(session, key1)).thenReturn(file1);
- when(componentDao.getNullableByKey(session, key2)).thenReturn(file2);
+ when(componentDao.selectNullableByKey(session, key1)).thenReturn(file1);
+ when(componentDao.selectNullableByKey(session, key2)).thenReturn(file2);
when(componentDao.getNullableByUuid(session, project.uuid())).thenReturn(project);
List<DuplicationsParser.Block> blocks = newArrayList();
String key1 = "org.codehaus.sonar:sonar-ws-client:src/main/java/org/sonar/wsclient/services/PropertyDeleteQuery.java";
ComponentDto file1 = ComponentTesting.newFileDto(project).setId(10L).setKey(key1).setLongName("PropertyDeleteQuery");
- when(componentDao.getNullableByKey(session, key1)).thenReturn(file1);
+ when(componentDao.selectNullableByKey(session, key1)).thenReturn(file1);
when(componentDao.getNullableByUuid(session, project.uuid())).thenReturn(project);
List<DuplicationsParser.Block> blocks = newArrayList();
// Current file
String key1 = "org.codehaus.sonar:sonar-plugin-api:src/main/java/org/sonar/api/utils/command/CommandExecutor.java";
currentFile = ComponentTesting.newFileDto(project1).setId(10L).setKey(key1).setLongName("CommandExecutor");
- when(componentDao.getNullableByKey(session, key1)).thenReturn(currentFile);
+ when(componentDao.selectNullableByKey(session, key1)).thenReturn(currentFile);
// File on same project
String key2 = "org.codehaus.sonar:sonar-plugin-api:src/main/java/com/sonar/orchestrator/util/CommandExecutor.java";
fileOnSameProject = ComponentTesting.newFileDto(project1).setId(11L).setKey(key2).setLongName("CommandExecutor");
- when(componentDao.getNullableByKey(session, key2)).thenReturn(fileOnSameProject);
+ when(componentDao.selectNullableByKey(session, key2)).thenReturn(fileOnSameProject);
// File on different project
String key3 = "com.sonarsource.orchestrator:sonar-orchestrator:src/main/java/com/sonar/orchestrator/util/CommandExecutor.java";
fileOnDifferentProject = ComponentTesting.newFileDto(project2).setId(12L).setKey(key3).setLongName("CommandExecutor");
- when(componentDao.getNullableByKey(session, key3)).thenReturn(fileOnDifferentProject);
+ when(componentDao.selectNullableByKey(session, key3)).thenReturn(fileOnDifferentProject);
parser = new DuplicationsParser(componentDao);
}
package org.sonar.server.duplication.ws;
import com.google.common.collect.Lists;
-import java.util.List;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
+import java.util.List;
+
import static com.google.common.collect.Lists.newArrayList;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.eq;
userSessionRule.addComponentPermission(UserRole.CODEVIEWER, "org.codehaus.sonar:sonar", componentKey);
ComponentDto componentDto = new ComponentDto().setId(10L);
- when(componentDao.getNullableByKey(session, componentKey)).thenReturn(componentDto);
+ when(componentDao.selectNullableByKey(session, componentKey)).thenReturn(componentDto);
String data = "{duplications}";
when(measureDao.findByComponentKeyAndMetricKey(session, componentKey, CoreMetrics.DUPLICATIONS_DATA_KEY)).thenReturn(
when(componentDao.getByUuid(session, uuid)).thenReturn(new ComponentDto().setKey(componentKey));
ComponentDto componentDto = new ComponentDto().setId(10L);
- when(componentDao.getNullableByKey(session, componentKey)).thenReturn(componentDto);
+ when(componentDao.selectNullableByKey(session, componentKey)).thenReturn(componentDto);
String data = "{duplications}";
when(measureDao.findByComponentKeyAndMetricKey(session, componentKey, CoreMetrics.DUPLICATIONS_DATA_KEY)).thenReturn(
userSessionRule.addComponentPermission(UserRole.CODEVIEWER, "org.codehaus.sonar:sonar", componentKey);
ComponentDto componentDto = new ComponentDto().setId(10L);
- when(componentDao.getNullableByKey(session, componentKey)).thenReturn(componentDto);
+ when(componentDao.selectNullableByKey(session, componentKey)).thenReturn(componentDto);
when(measureDao.findByComponentKeyAndMetricKey(session, componentKey, CoreMetrics.DUPLICATIONS_DATA_KEY)).thenReturn(null);
import static com.google.common.collect.Lists.newArrayList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.fail;
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.anyString;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.when;
public class ActionServiceTest {
Function function1 = mock(Function.class);
Function function2 = mock(Function.class);
- when(componentDao.getByKey(eq(session), anyString())).thenReturn(mock(ComponentDto.class));
+ when(componentDao.selectByKey(eq(session), anyString())).thenReturn(mock(ComponentDto.class));
when(issueService.getByKeyForUpdate(session, "ABCD")).thenReturn(issue);
actions.add("link-to-jira").setConditions(new AlwaysMatch()).setFunctions(function1, function2);
UserSession userSession = mock(ThreadLocalUserSession.class);
when(userSession.getLogin()).thenReturn("arthur");
- when(componentDao.getByKey(eq(session), anyString())).thenReturn(mock(ComponentDto.class));
+ when(componentDao.selectByKey(eq(session), anyString())).thenReturn(mock(ComponentDto.class));
when(issueService.getByKeyForUpdate(session, "ABCD")).thenReturn(issue);
actions.add("link-to-jira").setConditions(new AlwaysMatch()).setFunctions(function);
UserSession userSession = mock(ThreadLocalUserSession.class);
when(userSession.getLogin()).thenReturn("arthur");
- when(componentDao.getByKey(session, "struts")).thenReturn(new ComponentDto().setKey("struts"));
+ when(componentDao.selectByKey(session, "struts")).thenReturn(new ComponentDto().setKey("struts"));
when(issueService.getByKeyForUpdate(session, "ABCD")).thenReturn(issue.setProjectKey("struts"));
actions.add("link-to-jira").setConditions(new AlwaysMatch()).setFunctions(function);
public void not_execute_function_if_action_not_found() {
Function function = mock(Function.class);
- when(componentDao.getByKey(eq(session), anyString())).thenReturn(mock(ComponentDto.class));
+ when(componentDao.selectByKey(eq(session), anyString())).thenReturn(mock(ComponentDto.class));
when(issueService.getByKeyForUpdate(session, "ABCD")).thenReturn(issue);
actions.add("link-to-jira").setConditions(new AlwaysMatch()).setFunctions(function);
public void not_execute_function_if_action_is_not_supported() {
Function function = mock(Function.class);
- when(componentDao.getByKey(eq(session), anyString())).thenReturn(mock(ComponentDto.class));
+ when(componentDao.selectByKey(eq(session), anyString())).thenReturn(mock(ComponentDto.class));
when(issueService.getByKeyForUpdate(session, "ABCD")).thenReturn(issue);
actions.add("link-to-jira").setConditions(new NeverMatch()).setFunctions(function);
@Test
public void list_available_supported_actions() {
- when(componentDao.getByKey(eq(session), anyString())).thenReturn(mock(ComponentDto.class));
+ when(componentDao.selectByKey(eq(session), anyString())).thenReturn(mock(ComponentDto.class));
when(issueService.getByKeyForUpdate(session, "ABCD")).thenReturn(issue);
actions.add("link-to-jira").setConditions(new AlwaysMatch());
@Test
public void return_no_action() {
- when(componentDao.getByKey(eq(session), anyString())).thenReturn(mock(ComponentDto.class));
+ when(componentDao.selectByKey(eq(session), anyString())).thenReturn(mock(ComponentDto.class));
when(issueService.getByKeyForUpdate(session, "ABCD")).thenReturn(issue);
assertThat(actionService.listAvailableActions("ABCD")).isEmpty();
// .setLongName("My Project")
// .setQualifier(Qualifiers.PROJECT)
// .setScope(Scopes.PROJECT);
-// when(componentDao.getByKeys(dbSession, newHashSet(project.key()))).thenReturn(newArrayList(project));
+// when(componentDao.selectByKeys(dbSession, newHashSet(project.key()))).thenReturn(newArrayList(project));
//
// file = new ComponentDto()
// .setId(2L)
// .setParentProjectId(project.getId())
// .setKey("MyComponent")
// .setLongName("My Component");
-// when(componentDao.getByKeys(dbSession, newHashSet(file.key()))).thenReturn(newArrayList(file));
+// when(componentDao.selectByKeys(dbSession, newHashSet(file.key()))).thenReturn(newArrayList(file));
//
// IssueDoc issueDto = IssueTesting.newDoc("ABCD", file).setRuleKey(rule.ruleKey().toString());
// issue = issueDto.toDefaultIssue();
System2 system = mock(System2.class);
when(system.now()).thenReturn(2000000000L);
dbClient = new DbClient(getDatabase(), getMyBatis(),
- new ComponentDao(system),
+ new ComponentDao(),
new IssueDao(getMyBatis()),
new ResourceDao(getMyBatis(), system));
session = dbClient.openSession(false);
public void setUp() {
dbTester.truncateTables();
qualityProfileDao = new QualityProfileDao(dbTester.myBatis(), mock(System2.class));
- componentDao = new ComponentDao(mock(System2.class));
+ componentDao = new ComponentDao();
dbClient = new DbClient(dbTester.database(), dbTester.myBatis(), qualityProfileDao, new ActiveRuleDao(qualityProfileDao, new RuleDao(system2), system2));
session = dbClient.openSession(false);
import org.sonar.core.persistence.DbTester;
import org.sonar.core.qualityprofile.db.QualityProfileDao;
import org.sonar.core.qualityprofile.db.QualityProfileDto;
-import org.sonar.core.user.*;
+import org.sonar.core.user.AuthorizationDao;
+import org.sonar.core.user.GroupRoleDto;
+import org.sonar.core.user.RoleDao;
+import org.sonar.core.user.UserDto;
+import org.sonar.core.user.UserRoleDto;
import org.sonar.server.component.ComponentTesting;
import org.sonar.server.component.db.ComponentDao;
import org.sonar.server.db.DbClient;
dbTester.truncateTables();
dbClient = new DbClient(dbTester.database(), dbTester.myBatis(),
new QualityProfileDao(dbTester.myBatis(), system2),
- new ComponentDao(system2),
+ new ComponentDao(),
new AuthorizationDao(dbTester.myBatis()));
roleDao = new RoleDao();
session = dbClient.openSession(false);
QualityProfileDto.createFor("my-sonar-way-xoo2-34567").setLanguage(xoo2.getKey()).setName("My Sonar way").setParentKee("sonar-way-xoo2-23456"),
QualityProfileDto.createFor("sonar-way-other-666").setLanguage("other").setName("Sonar way").setDefault(true)
);
- new ComponentDao(mock(System2.class)).insert(session,
+ new ComponentDao().insert(session,
ComponentTesting.newProjectDto("project-uuid1"),
ComponentTesting.newProjectDto("project-uuid2"));
qualityProfileDao.insertProjectProfileAssociation("project-uuid1", "sonar-way-xoo2-23456", session);
*/
package org.sonar.server.source.ws;
-import org.junit.Rule;
-import org.sonar.api.utils.System2;
-import org.sonar.server.source.db.FileSourceDao;
-
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.experimental.categories.Category;
import org.junit.runner.RunWith;
import org.sonar.server.db.DbClient;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.exceptions.NotFoundException;
+import org.sonar.server.source.db.FileSourceDao;
import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
import org.sonar.test.DbTests;
+
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.fail;
-import static org.mockito.Mockito.mock;
@RunWith(MockitoJUnitRunner.class)
@Category(DbTests.class)
db.truncateTables();
this.session = db.myBatis().openSession(false);
- DbClient dbClient = new DbClient(db.database(), db.myBatis(), new FileSourceDao(db.myBatis()), new ComponentDao(mock(System2.class)));
+ DbClient dbClient = new DbClient(db.database(), db.myBatis(), new FileSourceDao(db.myBatis()), new ComponentDao());
tester = new WsTester(new SourcesWs(new HashAction(dbClient, userSessionRule)));
}
public void get_json() throws Exception {
String fileKey = "src/Foo.java";
userSessionRule.addComponentPermission(UserRole.CODEVIEWER, "polop", fileKey);
- when(componentDao.getByKey(session, fileKey)).thenReturn(file);
+ when(componentDao.selectByKey(session, fileKey)).thenReturn(file);
when(sourceService.getLinesAsTxt(file.uuid(), 1, null)).thenReturn(newArrayList(
"public class HelloWorld {",
public void limit_range() throws Exception {
String fileKey = "src/Foo.java";
userSessionRule.addComponentPermission(UserRole.CODEVIEWER, "polop", fileKey);
- when(componentDao.getByKey(session, fileKey)).thenReturn(file);
+ when(componentDao.selectByKey(session, fileKey)).thenReturn(file);
when(sourceService.getLinesAsTxt(file.uuid(), 1, 2)).thenReturn(newArrayList(
"public class HelloWorld {",
public void close_db_session() throws Exception {
String fileKey = "src/Foo.java";
userSessionRule.addComponentPermission(UserRole.CODEVIEWER, "polop", fileKey);
- when(componentDao.getByKey(session, fileKey)).thenThrow(new NotFoundException());
+ when(componentDao.selectByKey(session, fileKey)).thenThrow(new NotFoundException());
WsTester.TestRequest request = tester.newGetRequest("api/sources", "index").setParam("resource", fileKey);
try {
package org.sonar.server.source.ws;
import com.google.common.collect.ImmutableList;
-import java.util.Date;
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.config.Settings;
-import org.sonar.api.utils.System2;
import org.sonar.api.web.UserRole;
import org.sonar.core.component.ComponentDto;
import org.sonar.core.persistence.DbSession;
import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
+import java.util.Date;
+
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.failBecauseExceptionWasNotThrown;
import static org.junit.Assert.fail;
-import static org.mockito.Mockito.mock;
public class LinesActionTest {
htmlSourceDecorator = new HtmlSourceDecorator();
sourceLineIndex = new SourceLineIndex(esTester.client());
- componentDao = new ComponentDao(mock(System2.class));
+ componentDao = new ComponentDao();
DbClient dbClient = new DbClient(dbTester.database(), dbTester.myBatis(), componentDao);
session = dbClient.openSession(false);
wsTester = new WsTester(new SourcesWs(new LinesAction(dbClient, sourceLineIndex, htmlSourceDecorator, userSessionRule)));
.setItCoveredConditions(null)
.setDuplications(null)
.setUpdateDate(new Date())
- );
+ );
WsTester.TestRequest request = wsTester
.newGetRequest("api/sources", "lines")
.setItCoveredConditions(null)
.setDuplications(null)
.setUpdateDate(new Date())
- );
+ );
userSessionRule.login("login").addProjectUuidPermissions(UserRole.CODEVIEWER, PROJECT_UUID);
.execute();
}
- private void newFile(){
+ private void newFile() {
ComponentDto project = ComponentTesting.newProjectDto(PROJECT_UUID);
ComponentDto file = ComponentTesting.newFileDto(project, FILE_UUID).setKey(FILE_KEY);
componentDao.insert(session, project, file);
public void get_txt() throws Exception {
String fileKey = "src/Foo.java";
userSessionRule.addComponentPermission(UserRole.CODEVIEWER, "polop", fileKey);
- when(componentDao.getByKey(session, fileKey)).thenReturn(file);
+ when(componentDao.selectByKey(session, fileKey)).thenReturn(file);
when(sourceService.getLinesAsTxt(file.uuid(), null, null)).thenReturn(newArrayList(
"public class HelloWorld {",
package org.sonar.server.source.ws;
-import java.util.Date;
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
import org.junit.Test;
import org.sonar.api.config.Settings;
import org.sonar.api.utils.DateUtils;
-import org.sonar.api.utils.System2;
import org.sonar.api.web.UserRole;
import org.sonar.core.component.ComponentDto;
import org.sonar.core.persistence.DbSession;
import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
-import static org.mockito.Mockito.mock;
+import java.util.Date;
public class ScmActionTest {
public void setUp() {
dbTester.truncateTables();
esTester.truncateIndices();
- dbClient = new DbClient(dbTester.database(), dbTester.myBatis(), new ComponentDao(mock(System2.class)));
+ dbClient = new DbClient(dbTester.database(), dbTester.myBatis(), new ComponentDao());
session = dbClient.openSession(false);
tester = new WsTester(new SourcesWs(new ScmAction(dbClient, new SourceLineIndex(esTester.client()), userSessionRule)));
public void show_source() throws Exception {
String fileKey = "src/Foo.java";
userSessionRule.addComponentPermission(UserRole.CODEVIEWER, "polop", fileKey);
- when(componentDao.getByKey(session, fileKey)).thenReturn(file);
+ when(componentDao.selectByKey(session, fileKey)).thenReturn(file);
when(sourceService.getLinesAsHtml(eq(file.uuid()), anyInt(), anyInt())).thenReturn(newArrayList(
"/*",
" * Header",
public void show_source_with_from_and_to_params() throws Exception {
String fileKey = "src/Foo.java";
userSessionRule.addComponentPermission(UserRole.CODEVIEWER, "polop", fileKey);
- when(componentDao.getByKey(session, fileKey)).thenReturn(file);
+ when(componentDao.selectByKey(session, fileKey)).thenReturn(file);
when(sourceService.getLinesAsHtml(file.uuid(), 3, 5)).thenReturn(newArrayList(
" */",
"",
public void show_source_accept_from_less_than_one() throws Exception {
String fileKey = "src/Foo.java";
userSessionRule.addComponentPermission(UserRole.CODEVIEWER, "polop", fileKey);
- when(componentDao.getByKey(session, fileKey)).thenReturn(file);
+ when(componentDao.selectByKey(session, fileKey)).thenReturn(file);
when(sourceService.getLinesAsHtml(file.uuid(), 1, 5)).thenReturn(newArrayList(
" */",
"",
package org.sonar.server.test.ws;
-import java.util.Arrays;
-import java.util.List;
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.config.Settings;
-import org.sonar.api.utils.System2;
import org.sonar.api.web.UserRole;
import org.sonar.core.component.ComponentDto;
import org.sonar.core.persistence.DbSession;
import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
-import static org.mockito.Mockito.mock;
+import java.util.Arrays;
+import java.util.List;
public class TestsListActionTest {
DbClient dbClient;
@Before
public void setUp() {
- dbClient = new DbClient(db.database(), db.myBatis(), new ComponentDao(mock(System2.class)));
+ dbClient = new DbClient(db.database(), db.myBatis(), new ComponentDao());
dbSession = dbClient.openSession(false);
db.truncateTables();
es.truncateIndices();
*/
package org.sonar.server.ui.ws;
-import java.util.Date;
-import java.util.Locale;
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
import org.sonar.server.user.db.UserDao;
import org.sonar.server.ws.WsTester;
+import java.util.Date;
+import java.util.Locale;
+
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
activeDashboardDao = new ActiveDashboardDao(dbTester.myBatis());
dbClient = new DbClient(
dbTester.database(), dbTester.myBatis(), userDao, dashboardDao, activeDashboardDao,
- new ComponentDao(system), new SnapshotDao(system), new PropertiesDao(dbTester.myBatis()),
+ new ComponentDao(), new SnapshotDao(system), new PropertiesDao(dbTester.myBatis()),
new MeasureDao());
i18n = mock(I18n.class);
@Test
public void no_snapshot_connected_user_and_favorite() throws Exception {
int userId = 42;
- ComponentDto project = dbClient.componentDao().insert(session, ComponentTesting.newProjectDto("abcd")
- .setKey("polop").setName("Polop"));
+ ComponentDto project = ComponentTesting.newProjectDto("abcd")
+ .setKey("polop").setName("Polop");
+ dbClient.componentDao().insert(session, project);
dbClient.propertiesDao().setProperty(new PropertyDto().setKey("favourite").setResourceId(project.getId()).setUserId((long) userId), session);
session.commit();
Date snapshotDate = DateUtils.parseDateTime("2015-04-22T11:44:00+0200");
int userId = 42;
- ComponentDto project = dbClient.componentDao().insert(session, ComponentTesting.newProjectDto("abcd")
- .setKey("polop").setName("Polop"));
+ ComponentDto project = ComponentTesting.newProjectDto("abcd")
+ .setKey("polop").setName("Polop");
+ dbClient.componentDao().insert(session, project);
dbClient.snapshotDao().insert(session, new SnapshotDto().setCreatedAt(snapshotDate.getTime()).setVersion("3.14")
.setLast(true).setQualifier(project.qualifier()).setResourceId(project.getId()).setRootProjectId(project.getId()).setScope(project.scope()));
session.commit();
@Test
public void with_extensions() throws Exception {
- ComponentDto project = dbClient.componentDao().insert(session, ComponentTesting.newProjectDto("abcd")
- .setKey("polop").setName("Polop").setLanguage("xoo"));
+ ComponentDto project = ComponentTesting.newProjectDto("abcd")
+ .setKey("polop").setName("Polop").setLanguage("xoo");
+ dbClient.componentDao().insert(session, project);
dbClient.snapshotDao().insert(session, new SnapshotDto()
.setLast(true).setQualifier(project.qualifier()).setResourceId(project.getId()).setRootProjectId(project.getId()).setScope(project.scope()));
session.commit();
@Test
public void admin_with_extensions() throws Exception {
- ComponentDto project = dbClient.componentDao().insert(session, ComponentTesting.newProjectDto("abcd")
- .setKey("polop").setName("Polop").setLanguage("xoo"));
+ ComponentDto project = ComponentTesting.newProjectDto("abcd")
+ .setKey("polop").setName("Polop").setLanguage("xoo");
+ dbClient.componentDao().insert(session, project);
dbClient.snapshotDao().insert(session, new SnapshotDto()
.setLast(true).setQualifier(project.qualifier()).setResourceId(project.getId()).setRootProjectId(project.getId()).setScope(project.scope()));
session.commit();
import org.junit.Test;
import org.junit.experimental.categories.Category;
import org.sonar.api.config.Settings;
-import org.sonar.api.utils.System2;
import org.sonar.core.persistence.DbTester;
import org.sonar.server.component.db.ComponentDao;
import org.sonar.server.db.DbClient;
import static com.google.common.collect.Lists.newArrayList;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
@Category(DbTests.class)
public class ViewIndexerTest {
public void setUp() {
dbTester.truncateTables();
esTester.truncateIndices();
- indexer = new ViewIndexer(new DbClient(dbTester.database(), dbTester.myBatis(), new ComponentDao(mock(System2.class))), esTester.client());
+ indexer = new ViewIndexer(new DbClient(dbTester.database(), dbTester.myBatis(), new ComponentDao()), esTester.client());
indexer.setEnabled(true);
}
import org.apache.commons.lang.builder.ToStringBuilder;
import org.sonar.api.component.Component;
import org.sonar.api.resources.Scopes;
-import org.sonar.core.persistence.Dto;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
import java.util.Date;
-public class ComponentDto extends Dto<String> implements Component {
+public class ComponentDto implements Component {
public static final String MODULE_UUID_PATH_SEP = ".";
private String longName;
private String language;
private boolean enabled = true;
+
+ private Date createdAt;
private Long authorizationUpdatedAt;
public Long getId() {
return this;
}
+ public Date getCreatedAt() {
+ return createdAt;
+ }
+
+ public ComponentDto setCreatedAt(Date datetime) {
+ this.createdAt = datetime;
+ return this;
+ }
+
/**
* Only available on projects
*/
return this;
}
- @Override
public String getKey() {
return key();
}
.toString();
}
- @Override
- public ComponentDto setCreatedAt(Date datetime) {
- super.setCreatedAt(datetime);
- return this;
- }
-
- @Override
- public ComponentDto setUpdatedAt(Date datetime) {
- super.setUpdatedAt(datetime);
- return this;
- }
}
void insert(ComponentDto rule);
- void deleteByKey(String key);
-
List<ComponentDto> selectProvisionedProjects(Map<String, String> parameters, RowBounds rowBounds);
int countProvisionedProjects(Map<String, String> parameters);
#{language}, #{parentProjectId}, #{path}, #{copyResourceId}, #{enabled}, #{createdAt}, #{authorizationUpdatedAt})
</insert>
- <delete id="deleteByKey" parameterType="String">
- delete from projects where kee=#{key}
- </delete>
-
<select id="selectProvisionedProjects" parameterType="map" resultType="Component">
select <include refid="componentColumns"/>
from projects p
projects / sonarqube.git / commitdiff