return new PortfolioData(portfolioDto, component);
}
+ public final PortfolioData insertPrivatePortfolioData(Consumer<ComponentDto> dtoPopulator) {
+ ComponentDto component = insertComponentAndPortfolio(ComponentTesting.newPortfolio().setPrivate(true), true, dtoPopulator, defaults());
+ PortfolioDto portfolioDto = getPortfolioDto(component);
+ return new PortfolioData(portfolioDto, component);
+ }
+
public final PortfolioDto insertPrivatePortfolioDto(Consumer<ComponentDto> dtoPopulator) {
ComponentDto component = insertComponentAndPortfolio(ComponentTesting.newPortfolio().setPrivate(true), true, dtoPopulator, defaults());
return getPortfolioDto(component);
return portfolioDto;
}
+ public String portfolioUuid(){
+ return portfolioDto.getUuid();
+ }
+
+ public String rootComponentUuid(){
+ return rootComponent.uuid();
+ }
}
public String projectKey() {
return projectDto.getKey();
}
+
+ public String mainBranchUuid(){
+ return mainBranchDto.getUuid();
+ }
+
}
import org.sonar.db.DbTester;
import org.sonar.db.ce.CeQueueDto;
import org.sonar.db.component.ComponentDto;
+import org.sonar.db.project.ProjectDto;
import org.sonar.server.platform.NodeInformation;
import static org.assertj.core.api.Assertions.assertThat;
private final System2 system2 = System2.INSTANCE;
@Rule
- public DbTester db = DbTester.create(system2);
+ public DbTester db = DbTester.create(system2, true);
private final DbClient dbClient = db.getDbClient();
private final CeQueue ceQueue = new CeQueueImpl(system2, db.getDbClient(), UuidFactoryFast.getInstance(), mock(NodeInformation.class));
@Test
public void submitProjectExport_submits_task_with_project_uuid_and_submitterLogin_if_present() {
- ComponentDto projectDto = db.components().insertPrivateProject().getMainBranchComponent();
+ ProjectDto projectDto = db.components().insertPrivateProject().getProjectDto();
underTest.submitProjectExport(projectDto.getKey(), SOME_SUBMITTER_UUID);
assertThat(dbClient.ceQueueDao().selectAllInAscOrder(db.getSession()))
.extracting(CeQueueDto::getComponentUuid, CeQueueDto::getTaskType, CeQueueDto::getSubmitterUuid)
- .containsExactlyInAnyOrder(tuple(projectDto.uuid(), "PROJECT_EXPORT", SOME_SUBMITTER_UUID));
+ .containsExactlyInAnyOrder(tuple(projectDto.getUuid(), "PROJECT_EXPORT", SOME_SUBMITTER_UUID));
}
@Test
public void submitProjectExport_submits_task_with_project_uuid_and_no_submitterLogin_if_null() {
- ComponentDto projectDto = db.components().insertPrivateProject().getMainBranchComponent();
+ ProjectDto projectDto = db.components().insertPrivateProject().getProjectDto();
underTest.submitProjectExport(projectDto.getKey(), null);
assertThat(dbClient.ceQueueDao().selectAllInAscOrder(db.getSession()))
.extracting(CeQueueDto::getComponentUuid, CeQueueDto::getTaskType, CeQueueDto::getSubmitterUuid)
- .containsExactlyInAnyOrder(tuple(projectDto.uuid(), "PROJECT_EXPORT", null));
+ .containsExactlyInAnyOrder(tuple(projectDto.getUuid(), "PROJECT_EXPORT", null));
}
}
@Rule
public final UserSessionRule userSession = UserSessionRule.standalone();
@Rule
- public final DbTester db = DbTester.create(System2.INSTANCE);
+ public final DbTester db = DbTester.create(System2.INSTANCE, true);
private final ProjectDefaultVisibility projectDefaultVisibility = mock(ProjectDefaultVisibility.class);
public class CeQueueCleanerIT {
@Rule
- public final DbTester dbTester = DbTester.create(System2.INSTANCE);
+ public final DbTester dbTester = DbTester.create(System2.INSTANCE, true);
private final ServerUpgradeStatus serverUpgradeStatus = mock(ServerUpgradeStatus.class);
private final CeQueue queue = mock(CeQueue.class);
import org.sonar.db.ce.CeTaskMessageDto;
import org.sonar.db.ce.CeTaskMessageType;
import org.sonar.db.ce.CeTaskTypes;
+import org.sonar.db.component.BranchDto;
import org.sonar.db.component.BranchType;
import org.sonar.db.component.ComponentDto;
+import org.sonar.db.component.PortfolioData;
+import org.sonar.db.component.ProjectData;
import org.sonar.db.component.SnapshotDto;
+import org.sonar.db.portfolio.PortfolioDto;
+import org.sonar.db.project.ProjectDto;
import org.sonar.server.exceptions.BadRequestException;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.exceptions.NotFoundException;
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
private final TaskFormatter formatter = new TaskFormatter(db.getDbClient(), System2.INSTANCE);
private final ActivityAction underTest = new ActivityAction(userSession, db.getDbClient(), formatter, new CeTaskProcessor[] {mock(CeTaskProcessor.class)});
@Test
public void get_all_past_activity() {
logInAsSystemAdministrator();
- ComponentDto project1 = db.components().insertPrivateProject().getMainBranchComponent();
- ComponentDto project2 = db.components().insertPrivateProject().getMainBranchComponent();
- SnapshotDto analysisProject1 = db.components().insertSnapshot(project1);
- insertActivity("T1", project1, SUCCESS, analysisProject1);
- insertActivity("T2", project2, FAILED, null);
+ ProjectData project1 = db.components().insertPrivateProject();
+ ProjectData project2 = db.components().insertPrivateProject();
+ SnapshotDto analysisProject1 = db.components().insertSnapshot(project1.getMainBranchDto());
+ insertActivity("T1", project1.projectUuid(), project1.mainBranchUuid(), SUCCESS, analysisProject1);
+ insertActivity("T2", project2.projectUuid(), project2.mainBranchUuid(), FAILED, null);
ActivityResponse activityResponse = call(ws.newRequest()
.setParam(PARAM_MAX_EXECUTED_AT, formatDateTime(EXECUTED_AT + 2_000)));
assertThat(task.getId()).isEqualTo("T2");
assertThat(task.getStatus()).isEqualTo(Ce.TaskStatus.FAILED);
assertThat(task.getNodeName()).isEqualTo(NODE_NAME);
- assertThat(task.getComponentId()).isEqualTo(project2.uuid());
+ assertThat(task.getComponentId()).isEqualTo(project2.getMainBranchComponent().uuid());
assertThat(task.hasAnalysisId()).isFalse();
assertThat(task.getExecutionTimeMs()).isEqualTo(500L);
assertThat(task.getWarningCount()).isZero();
assertThat(task.getId()).isEqualTo("T1");
assertThat(task.getNodeName()).isEqualTo(NODE_NAME);
assertThat(task.getStatus()).isEqualTo(Ce.TaskStatus.SUCCESS);
- assertThat(task.getComponentId()).isEqualTo(project1.uuid());
+ assertThat(task.getComponentId()).isEqualTo(project1.getMainBranchComponent().uuid());
assertThat(task.getWarningCount()).isZero();
}
@Test
public void filter_by_status() {
logInAsSystemAdministrator();
- ComponentDto project1 = db.components().insertPrivateProject().getMainBranchComponent();
- ComponentDto project2 = db.components().insertPrivateProject().getMainBranchComponent();
+ ProjectData project1 = db.components().insertPrivateProject();
+ ProjectData project2 = db.components().insertPrivateProject();
insertActivity("T1", project1, SUCCESS);
insertActivity("T2", project2, FAILED);
insertQueue("T3", project1, IN_PROGRESS);
@Test
public void filter_by_max_executed_at_exclude() {
logInAsSystemAdministrator();
- ComponentDto project1 = db.components().insertPrivateProject().getMainBranchComponent();
- ComponentDto project2 = db.components().insertPrivateProject().getMainBranchComponent();
+ ProjectData project1 = db.components().insertPrivateProject();
+ ProjectData project2 = db.components().insertPrivateProject();
insertActivity("T1", project1, SUCCESS);
insertActivity("T2", project2, FAILED);
insertQueue("T3", project1, IN_PROGRESS);
@Test
public void filter_by_min_submitted_and_max_executed_at_include_day() {
logInAsSystemAdministrator();
- ComponentDto project = db.components().insertPrivateProject().getMainBranchComponent();
+ ProjectData project = db.components().insertPrivateProject();
insertActivity("T1", project, SUCCESS);
String today = formatDate(new Date(EXECUTED_AT));
@Test
public void filter_on_current_activities() {
logInAsSystemAdministrator();
- ComponentDto project = db.components().insertPrivateProject().getMainBranchComponent();
+ ProjectData project = db.components().insertPrivateProject();
// T2 is the current activity (the most recent one)
insertActivity("T1", project, SUCCESS);
insertActivity("T2", project, FAILED);
@Test
public void limit_results() {
logInAsSystemAdministrator();
- ComponentDto project1 = db.components().insertPrivateProject().getMainBranchComponent();
- ComponentDto project2 = db.components().insertPrivateProject().getMainBranchComponent();
+ ProjectData project1 = db.components().insertPrivateProject();
+ ProjectData project2 = db.components().insertPrivateProject();
insertActivity("T1", project1, SUCCESS);
insertActivity("T2", project2, FAILED);
insertQueue("T3", project1, IN_PROGRESS);
@Test
public void remove_queued_already_completed() {
logInAsSystemAdministrator();
- ComponentDto project1 = db.components().insertPrivateProject().getMainBranchComponent();
+ ProjectData project1 = db.components().insertPrivateProject();
insertActivity("T1", project1, SUCCESS);
insertQueue("T1", project1, IN_PROGRESS);
@Test
public void return_warnings_count_on_queue_and_activity_and_warnings_list() {
logInAsSystemAdministrator();
- ComponentDto project1 = db.components().insertPrivateProject().getMainBranchComponent();
- ComponentDto project2 = db.components().insertPrivateProject().getMainBranchComponent();
+ ProjectData project1 = db.components().insertPrivateProject();
+ ProjectData project2 = db.components().insertPrivateProject();
insertActivity("T1", project1, SUCCESS);
insertActivity("T2", project2, FAILED);
insertQueue("T3", project1, IN_PROGRESS);
@Test
public void project_administrator_can_access_his_project_activity_using_component_key() {
- ComponentDto project1 = db.components().insertPrivateProject().getMainBranchComponent();
- ComponentDto project2 = db.components().insertPrivateProject().getMainBranchComponent();
+ ProjectData project1 = db.components().insertPrivateProject();
+ ProjectData project2 = db.components().insertPrivateProject();
// no need to be a system admin
- userSession.logIn().addProjectPermission(UserRole.ADMIN, project1);
+ userSession.logIn().addProjectPermission(UserRole.ADMIN, project1.getProjectDto());
insertActivity("T1", project1, SUCCESS);
insertActivity("T2", project2, FAILED);
- ActivityResponse activityResponse = call(ws.newRequest().setParam("component", project1.getKey()));
+ ActivityResponse activityResponse = call(ws.newRequest().setParam("component", project1.projectKey()));
assertThat(activityResponse.getTasksCount()).isOne();
assertThat(activityResponse.getTasks(0).getId()).isEqualTo("T1");
assertThat(activityResponse.getTasks(0).getStatus()).isEqualTo(Ce.TaskStatus.SUCCESS);
- assertThat(activityResponse.getTasks(0).getComponentId()).isEqualTo(project1.uuid());
+ assertThat(activityResponse.getTasks(0).getComponentId()).isEqualTo(project1.getMainBranchComponent().uuid());
}
@Test
public void return_401_if_user_is_not_logged_in() {
- ComponentDto project = db.components().insertPrivateProject().getMainBranchComponent();
+ ProjectData project = db.components().insertPrivateProject();
userSession.anonymous();
- TestRequest request = ws.newRequest().setParam("componentId", project.uuid());
+ TestRequest request = ws.newRequest().setParam("componentId", project.projectUuid());
assertThatThrownBy(() -> call(request))
.isInstanceOf(UnauthorizedException.class)
.hasMessage("Authentication is required");
@Test
public void search_activity_by_component_name() {
- ComponentDto struts = db.components().insertPrivateProject(c -> c.setName("old apache struts")).getMainBranchComponent();
- ComponentDto zookeeper = db.components().insertPrivateProject(c -> c.setName("new apache zookeeper")).getMainBranchComponent();
- ComponentDto eclipse = db.components().insertPrivateProject(c -> c.setName("eclipse")).getMainBranchComponent();
- db.components().insertSnapshot(struts);
- db.components().insertSnapshot(zookeeper);
- db.components().insertSnapshot(eclipse);
+ ProjectData struts = db.components().insertPrivateProject(c -> c.setName("old apache struts"));
+ ProjectData zookeeper = db.components().insertPrivateProject(c -> c.setName("new apache zookeeper"));
+ ProjectData eclipse = db.components().insertPrivateProject(c -> c.setName("eclipse"));
+ db.components().insertSnapshot(struts.getMainBranchDto());
+ db.components().insertSnapshot(zookeeper.getMainBranchDto());
+ db.components().insertSnapshot(eclipse.getMainBranchDto());
logInAsSystemAdministrator();
insertActivity("T1", struts, SUCCESS);
insertActivity("T2", zookeeper, SUCCESS);
@Test
public void search_activity_returns_views() {
- ComponentDto apacheView = db.components().insertPrivatePortfolio(v -> v.setName("Apache View"));
- db.components().insertSnapshot(apacheView);
+ PortfolioData apacheView = db.components().insertPrivatePortfolioData(v -> v.setName("Apache View"));
+ db.components().insertSnapshot(apacheView.getPortfolioDto());
logInAsSystemAdministrator();
insertActivity("T2", apacheView, SUCCESS);
@Test
public void search_activity_returns_application() {
- ComponentDto apacheApp = db.components().insertPublicApplication(a -> a.setName("Apache App")).getMainBranchComponent();
- db.components().insertSnapshot(apacheApp);
+ ProjectData apacheApp = db.components().insertPublicApplication(a -> a.setName("Apache App"));
+ db.components().insertSnapshot(apacheApp.getMainBranchDto());
logInAsSystemAdministrator();
insertActivity("T2", apacheApp, SUCCESS);
@Test
public void search_task_id_in_queue_ignoring_other_parameters() {
logInAsSystemAdministrator();
- ComponentDto project = db.components().insertPrivateProject().getMainBranchComponent();
+ ProjectData project = db.components().insertPrivateProject();
insertQueue("T1", project, IN_PROGRESS);
ActivityResponse result = call(
@Test
public void search_task_id_in_activity() {
logInAsSystemAdministrator();
- ComponentDto project = db.components().insertPrivateProject().getMainBranchComponent();
+ ProjectData project = db.components().insertPrivateProject();
insertActivity("T1", project, SUCCESS);
ActivityResponse result = call(ws.newRequest().setParam(Param.TEXT_QUERY, "T1"));
// WS api/ce/task must be used in order to search by task id.
// Here it's a convenient feature of search by text query, which
// is reserved to roots
- ComponentDto view = db.components().insertPrivatePortfolio();
+ PortfolioData view = db.components().insertPrivatePortfolioData();
insertActivity("T1", view, SUCCESS);
- userSession.logIn().addProjectPermission(UserRole.ADMIN, view);
+ userSession.logIn().addProjectPermission(UserRole.ADMIN, view.getRootComponent());
TestRequest request = ws.newRequest().setParam(TEXT_QUERY, "T1");
assertThatThrownBy(() -> call(request))
@Test
public void branch_in_past_activity() {
logInAsSystemAdministrator();
- ComponentDto project = db.components().insertPrivateProject().getMainBranchComponent();
- userSession.addProjectPermission(UserRole.USER, project);
+ ProjectData project = db.components().insertPrivateProject();
+ userSession.addProjectPermission(UserRole.USER, project.getProjectDto());
String branchName = "branch1";
- ComponentDto branch = db.components().insertProjectBranch(project, b -> b.setBranchType(BRANCH).setKey(branchName));
+ BranchDto branch = db.components().insertProjectBranch(project.getProjectDto(), b -> b.setBranchType(BRANCH).setKey(branchName));
SnapshotDto analysis = db.components().insertSnapshot(branch);
- CeActivityDto activity = insertActivity("T1", project, SUCCESS, analysis);
+ CeActivityDto activity = insertActivity("T1", project.projectUuid(), project.mainBranchUuid(), SUCCESS, analysis);
insertCharacteristic(activity, BRANCH_KEY, branchName);
insertCharacteristic(activity, BRANCH_TYPE_KEY, BRANCH.name());
@Test
public void pull_request_in_past_activity() {
logInAsSystemAdministrator();
- ComponentDto project = db.components().insertPrivateProject().getMainBranchComponent();
- userSession.addProjectPermission(UserRole.USER, project);
+ ProjectData project = db.components().insertPrivateProject();
+ userSession.addProjectPermission(UserRole.USER, project.getProjectDto());
String pullRequestKey = RandomStringUtils.randomAlphanumeric(100);
- ComponentDto pullRequest = db.components().insertProjectBranch(project, b -> b.setBranchType(BranchType.PULL_REQUEST).setKey(pullRequestKey));
+ BranchDto pullRequest = db.components().insertProjectBranch(project.getProjectDto(), b -> b.setBranchType(BranchType.PULL_REQUEST).setKey(pullRequestKey));
SnapshotDto analysis = db.components().insertSnapshot(pullRequest);
- CeActivityDto activity = insertActivity("T1", project, SUCCESS, analysis);
+ CeActivityDto activity = insertActivity("T1", project.projectUuid(), project.getMainBranchComponent().uuid(), SUCCESS, analysis);
insertCharacteristic(activity, PULL_REQUEST, pullRequestKey);
ActivityResponse response = ws.newRequest().executeProtobuf(ActivityResponse.class);
@Test
public void throws_IAE_if_page_is_higher_than_available() {
logInAsSystemAdministrator();
- ComponentDto project1 = db.components().insertPrivateProject().getMainBranchComponent();
+ ProjectData project1 = db.components().insertPrivateProject();
insertActivity("T1", project1, SUCCESS);
insertActivity("T2", project1, SUCCESS);
@Test
public void filter_out_duplicate_tasks_in_progress_and_success() {
logInAsSystemAdministrator();
- ComponentDto project1 = db.components().insertPrivateProject().getMainBranchComponent();
- ComponentDto project2 = db.components().insertPrivateProject().getMainBranchComponent();
- ComponentDto project3 = db.components().insertPrivateProject().getMainBranchComponent();
+ ProjectData project1 = db.components().insertPrivateProject();
+ ProjectData project2 = db.components().insertPrivateProject();
+ ProjectData project3 = db.components().insertPrivateProject();
insertQueue("T2", project2, IN_PROGRESS);
insertQueue("T3", project3, IN_PROGRESS);
insertActivity("T1", project1, SUCCESS);
userSession.logIn().setSystemAdministrator();
}
- private CeQueueDto insertQueue(String taskUuid, @Nullable ComponentDto project, CeQueueDto.Status status) {
+ private CeQueueDto insertQueue(String taskUuid, @Nullable ProjectData project, CeQueueDto.Status status) {
CeQueueDto queueDto = new CeQueueDto();
queueDto.setTaskType(CeTaskTypes.REPORT);
- if (project != null ) {
- queueDto.setComponentUuid(project.uuid());
- queueDto.setEntityUuid(project.uuid());
+ if (project != null) {
+ queueDto.setComponentUuid(project.mainBranchUuid());
+ queueDto.setEntityUuid(project.projectUuid());
}
queueDto.setUuid(taskUuid);
queueDto.setStatus(status);
return queueDto;
}
- private CeActivityDto insertActivity(String taskUuid, ComponentDto project, Status status) {
- return insertActivity(taskUuid, project, status, db.components().insertSnapshot(project));
+ private CeActivityDto insertActivity(String taskUuid, ProjectData project, Status status) {
+ return insertActivity(taskUuid, project.projectUuid(), project.mainBranchUuid(), status, db.components().insertSnapshot(project.getMainBranchDto()));
}
- private CeActivityDto insertActivity(String taskUuid, ComponentDto project, Status status, @Nullable SnapshotDto analysis) {
+ private CeActivityDto insertActivity(String taskUuid, PortfolioData portfolio, Status status) {
+ return insertActivity(taskUuid, portfolio.portfolioUuid(), portfolio.rootComponentUuid(), status, db.components().insertSnapshot(portfolio.getPortfolioDto()));
+ }
+
+ private CeActivityDto insertActivity(String taskUuid, String entityUuid, String rootCompomentUuid, Status status, @Nullable SnapshotDto analysis) {
CeQueueDto queueDto = new CeQueueDto();
queueDto.setTaskType(CeTaskTypes.REPORT);
- queueDto.setComponentUuid(project.uuid());
- queueDto.setEntityUuid(project.uuid());
+ queueDto.setComponentUuid(rootCompomentUuid);
+ queueDto.setEntityUuid(entityUuid);
queueDto.setUuid(taskUuid);
queueDto.setCreatedAt(EXECUTED_AT);
CeActivityDto activityDto = new CeActivityDto(queueDto);
@Rule
public UserSessionRule userSession = UserSessionRule.standalone().logIn().setSystemAdministrator();
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
private final System2 system2 = mock(System2.class);
private final DbClient dbClient = db.getDbClient();
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
private final TaskFormatter formatter = new TaskFormatter(db.getDbClient(), System2.INSTANCE);
private final ComponentAction underTest = new ComponentAction(userSession, db.getDbClient(), formatter, TestComponentFinder.from(db));
public UserSessionRule userSession = UserSessionRule.standalone();
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
private static int counter = 1;
public IssueIndexSyncProgressChecker issueIndexSyncProgressCheckerMock = mock(IssueIndexSyncProgressChecker.class);
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
private WsActionTester ws = new WsActionTester(new IndexationStatusAction(db.getDbClient(), issueIndexSyncProgressCheckerMock));
public final UserSessionRule userSession = UserSessionRule.standalone();
@Rule
- public final DbTester db = DbTester.create(System2.INSTANCE);
+ public final DbTester db = DbTester.create(System2.INSTANCE, true);
private final TaskFormatter formatter = new TaskFormatter(db.getDbClient(), System2.INSTANCE);
private final TaskAction underTest = new TaskAction(db.getDbClient(), formatter, userSession);
public static final DbIssues.MessageFormatting MESSAGE_FORMATTING = DbIssues.MessageFormatting.newBuilder().setStart(0).setEnd(4).setType(CODE).build();
@Rule
- public DbTester dbTester = DbTester.create(System2.INSTANCE);
+ public DbTester dbTester = DbTester.create(System2.INSTANCE, true);
@Rule
public EsTester es = EsTester.create();
@Rule
public class PullTaintActionResponseWriterIT {
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
public UserSessionRule userSession = UserSessionRule.standalone().logIn();
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
private final WsActionTester ws = new WsActionTester(new SearchAction(userSession, db.getDbClient()));
public class DefaultTemplatesResolverImplIT {
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
private ResourceTypesRule resourceTypesWithPortfoliosInstalled = new ResourceTypesRule().setRootQualifiers(PROJECT, APP, VIEW);
private ResourceTypesRule resourceTypesWithApplicationInstalled = new ResourceTypesRule().setRootQualifiers(PROJECT, APP);
public class GroupPermissionChangerIT {
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
private final ResourceTypes resourceTypes = new ResourceTypesRule().setRootQualifiers(Qualifiers.PROJECT);
private final PermissionService permissionService = new PermissionServiceImpl(resourceTypes);
public class UserPermissionChangerIT {
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
private final ResourceTypes resourceTypes = new ResourceTypesRule().setRootQualifiers(Qualifiers.PROJECT);
@Rule
public TemporaryFolder temp = new TemporaryFolder();
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
@Rule
public UserSessionRule userSession = UserSessionRule.standalone().logIn();
import org.sonar.api.server.ws.WebService.Param;
import org.sonar.api.utils.DateUtils;
import org.sonar.db.DbTester;
+import org.sonar.db.component.BranchDto;
import org.sonar.db.component.ComponentDto;
+import org.sonar.db.component.ProjectData;
+import org.sonar.db.project.ProjectDto;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.TestRequest;
public final UserSessionRule userSession = UserSessionRule.standalone();
@Rule
- public final DbTester db = DbTester.create();
+ public final DbTester db = DbTester.create(true);
private final WsActionTester ws = new WsActionTester(new SearchAction(db.getDbClient(), userSession));
@Test
public void search_projects() {
userSession.addPermission(ADMINISTER);
- ComponentDto project = db.components().insertPrivateProject(p -> p.setKey(PROJECT_KEY_1)).getMainBranchComponent();
- db.components().insertPrivateProject(p -> p.setKey(PROJECT_KEY_2)).getMainBranchComponent();
+ ProjectData project = db.components().insertPrivateProject(p -> p.setKey(PROJECT_KEY_1));
+ db.components().insertPrivateProject(p -> p.setKey(PROJECT_KEY_2));
db.components().insertPublicPortfolio();
- ComponentDto directory = newDirectory(project, "dir");
+ ComponentDto directory = newDirectory(project.getMainBranchComponent(), "dir");
ComponentDto file = newFileDto(directory);
db.components().insertComponents(directory, file);
@Test
public void search_views() {
userSession.addPermission(ADMINISTER);
- db.components().insertPrivateProject(p -> p.setKey(PROJECT_KEY_1)).getMainBranchComponent();
+ db.components().insertPrivateProject(p -> p.setKey(PROJECT_KEY_1));
db.components().insertPublicPortfolio(p -> p.setKey("view1"));
SearchWsResponse response = call(SearchRequest.builder().setQualifiers(singletonList("VW")).build());
@Test
public void search_projects_and_views() {
userSession.addPermission(ADMINISTER);
- db.components().insertPrivateProject(p -> p.setKey(PROJECT_KEY_1)).getMainBranchComponent();
+ db.components().insertPrivateProject(p -> p.setKey(PROJECT_KEY_1));
db.components().insertPublicPortfolio(p -> p.setKey("view1"));
SearchWsResponse response = call(SearchRequest.builder().setQualifiers(asList("TRK", "VW")).build());
@Test
public void search_all() {
userSession.addPermission(ADMINISTER);
- db.components().insertPrivateProject(p -> p.setKey(PROJECT_KEY_1)).getMainBranchComponent();
- db.components().insertPrivateProject(p -> p.setKey(PROJECT_KEY_2)).getMainBranchComponent();
- db.components().insertPrivateProject(p -> p.setKey(PROJECT_KEY_3)).getMainBranchComponent();
+ db.components().insertPrivateProject(p -> p.setKey(PROJECT_KEY_1));
+ db.components().insertPrivateProject(p -> p.setKey(PROJECT_KEY_2));
+ db.components().insertPrivateProject(p -> p.setKey(PROJECT_KEY_3));
SearchWsResponse response = call(SearchRequest.builder().build());
assertThat(response.getComponentsList()).extracting(Component::getKey).containsOnly(PROJECT_KEY_1, PROJECT_KEY_2, PROJECT_KEY_3);
long inBetween = 2_000_000_000L;
long recentTime = 3_000_000_000L;
- ComponentDto oldProject = db.components().insertPublicProject().getMainBranchComponent();
- db.getDbClient().snapshotDao().insert(db.getSession(), newAnalysis(oldProject).setCreatedAt(aLongTimeAgo));
- ComponentDto branch = db.components().insertProjectBranch(oldProject);
+ ProjectData oldProject = db.components().insertPublicProject();
+ db.getDbClient().snapshotDao().insert(db.getSession(), newAnalysis(oldProject.getMainBranchDto()).setCreatedAt(aLongTimeAgo));
+ BranchDto branch = db.components().insertProjectBranch(oldProject.getProjectDto());
db.getDbClient().snapshotDao().insert(db.getSession(), newAnalysis(branch).setCreatedAt(inBetween));
- ComponentDto recentProject = db.components().insertPublicProject().getMainBranchComponent();
- db.getDbClient().snapshotDao().insert(db.getSession(), newAnalysis(recentProject).setCreatedAt(recentTime));
+ ProjectData recentProject = db.components().insertPublicProject();
+ db.getDbClient().snapshotDao().insert(db.getSession(), newAnalysis(recentProject.getMainBranchDto()).setCreatedAt(recentTime));
db.commit();
SearchWsResponse result = call(SearchRequest.builder().setAnalyzedBefore(toStringAtUTC(new Date(recentTime + 1_000))).build());
assertThat(result.getComponentsList()).extracting(Component::getKey, Component::getLastAnalysisDate)
- .containsExactlyInAnyOrder(tuple(oldProject.getKey(), formatDateTime(inBetween)), tuple(recentProject.getKey(), formatDateTime(recentTime)));
+ .containsExactlyInAnyOrder(tuple(oldProject.getProjectDto().getKey(), formatDateTime(inBetween)), tuple(recentProject.projectKey(), formatDateTime(recentTime)));
result = call(SearchRequest.builder().setAnalyzedBefore(toStringAtUTC(new Date(recentTime))).build());
assertThat(result.getComponentsList()).extracting(Component::getKey, Component::getLastAnalysisDate)
- .containsExactlyInAnyOrder(tuple(oldProject.getKey(), formatDateTime(inBetween)));
+ .containsExactlyInAnyOrder(tuple(oldProject.getProjectDto().getKey(), formatDateTime(inBetween)));
result = call(SearchRequest.builder().setAnalyzedBefore(toStringAtUTC(new Date(aLongTimeAgo + 1_000L))).build());
assertThat(result.getComponentsList()).isEmpty();
@Test
public void does_not_return_branches_when_searching_by_key() {
- ComponentDto project = db.components().insertPublicProject().getMainBranchComponent();
- ComponentDto branch = db.components().insertProjectBranch(project);
+ ProjectDto project = db.components().insertPublicProject().getProjectDto();
+ db.components().insertProjectBranch(project);
userSession.addPermission(ADMINISTER);
SearchWsResponse response = call(SearchRequest.builder().build());
@Test
public void result_is_paginated() {
userSession.addPermission(ADMINISTER);
- List<ComponentDto> componentDtoList = new ArrayList<>();
for (int i = 1; i <= 9; i++) {
int j = i;
- componentDtoList.add(db.components().insertPrivateProject("project-uuid-" + i, p -> p.setKey("project-key-" + j).setName("Project Name " + j)).getMainBranchComponent());
+ db.components().insertPrivateProject("project-uuid-" + i, p -> p.setKey("project-key-" + j).setName("Project Name " + j));
}
SearchWsResponse response = call(SearchRequest.builder().setPage(2).setPageSize(3).build());
@Test
public void provisioned_projects() {
userSession.addPermission(ADMINISTER);
- ComponentDto provisionedProject = db.components().insertPrivateProject().getMainBranchComponent();
- ComponentDto analyzedProject = db.components().insertPrivateProject().getMainBranchComponent();
- db.components().insertSnapshot(newAnalysis(analyzedProject));
+ ProjectDto provisionedProject = db.components().insertPrivateProject().getProjectDto();
+ ProjectData analyzedProject = db.components().insertPrivateProject();
+ db.components().insertSnapshot(newAnalysis(analyzedProject.getMainBranchDto()));
SearchWsResponse response = call(SearchRequest.builder().setOnProvisionedOnly(true).build());
assertThat(response.getComponentsList()).extracting(Component::getKey)
.containsExactlyInAnyOrder(provisionedProject.getKey())
- .doesNotContain(analyzedProject.getKey());
+ .doesNotContain(analyzedProject.projectKey());
}
@Test
public void search_by_component_keys() {
userSession.addPermission(ADMINISTER);
- ComponentDto jdk = db.components().insertPrivateProject().getMainBranchComponent();
- ComponentDto sonarqube = db.components().insertPrivateProject().getMainBranchComponent();
- ComponentDto sonarlint = db.components().insertPrivateProject().getMainBranchComponent();
+ ProjectDto jdk = db.components().insertPrivateProject().getProjectDto();
+ ProjectDto sonarqube = db.components().insertPrivateProject().getProjectDto();
+ ProjectDto sonarlint = db.components().insertPrivateProject().getProjectDto();
SearchWsResponse result = call(SearchRequest.builder()
.setProjects(Arrays.asList(jdk.getKey(), sonarqube.getKey()))
@Test
public void json_example() {
userSession.addPermission(ADMINISTER);
- ComponentDto publicProject = db.components().insertPublicProject("project-uuid-1", p -> p.setName("Project Name 1").setKey("project-key-1").setPrivate(false)).getMainBranchComponent();
- ComponentDto privateProject = db.components().insertPrivateProject("project-uuid-2", p -> p.setName("Project Name 1").setKey("project-key-2")).getMainBranchComponent();
- db.getDbClient().snapshotDao().insert(db.getSession(), newAnalysis(publicProject)
+ ProjectData publicProject = db.components().insertPublicProject("project-uuid-1", p -> p.setName("Project Name 1").setKey("project-key-1").setPrivate(false));
+ ProjectData privateProject = db.components().insertPrivateProject("project-uuid-2", p -> p.setName("Project Name 1").setKey("project-key-2"));
+ db.getDbClient().snapshotDao().insert(db.getSession(), newAnalysis(publicProject.getMainBranchDto())
.setCreatedAt(parseDateTime("2017-03-01T11:39:03+0300").getTime())
.setRevision("cfb82f55c6ef32e61828c4cb3db2da12795fd767"));
- db.getDbClient().snapshotDao().insert(db.getSession(), newAnalysis(privateProject)
+ db.getDbClient().snapshotDao().insert(db.getSession(), newAnalysis(privateProject.getMainBranchDto())
.setCreatedAt(parseDateTime("2017-03-02T15:21:47+0300").getTime())
.setRevision("7be96a94ac0c95a61ee6ee0ef9c6f808d386a355"));
db.commit();
private static final String ANOTHER_KEY = "another_key";
@Rule
- public final DbTester db = DbTester.create(System2.INSTANCE);
+ public final DbTester db = DbTester.create(System2.INSTANCE, true);
@Rule
public final UserSessionRule userSessionRule = UserSessionRule.standalone();
private final DbClient dbClient = db.getDbClient();
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
private DbClient dbClient = db.getDbClient();
private DbSession dbSession = db.getSession();
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
private final DbClient dbClient = db.getDbClient();
private final DbSession dbSession = db.getSession();
private static final String SOME_KEY = "some key";
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
import org.sonar.db.component.ComponentTesting;
import org.sonar.db.component.ProjectData;
import org.sonar.db.component.ProjectLinkDto;
+import org.sonar.db.project.ProjectDto;
import org.sonar.server.component.TestComponentFinder;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.exceptions.NotFoundException;
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
private final DbClient dbClient = db.getDbClient();
private final DbSession dbSession = db.getSession();
@Test
public void example_with_key() {
- ComponentDto project = db.components().insertPrivateProject().getMainBranchComponent();
+ ProjectDto project = db.components().insertPrivateProject().getProjectDto();
logInAsProjectAdministrator(project);
String result = ws.newRequest()
@Test
public void example_with_id() {
- ComponentDto project = db.components().insertPrivateProject().getMainBranchComponent();
+ ProjectDto project = db.components().insertPrivateProject().getProjectDto();
logInAsProjectAdministrator(project);
String result = ws.newRequest()
.setMethod("POST")
- .setParam(PARAM_PROJECT_ID, project.uuid())
+ .setParam(PARAM_PROJECT_ID, project.getUuid())
.setParam(PARAM_NAME, "Custom")
.setParam(PARAM_URL, "http://example.org")
.execute().getInput();
@Test
public void require_project_admin() {
- ComponentDto project = db.components().insertPrivateProject().getMainBranchComponent();
+ ProjectDto project = db.components().insertPrivateProject().getProjectDto();
logInAsProjectAdministrator(project);
createAndTest(project);
@Test
public void with_long_name() {
- ComponentDto project = db.components().insertPrivateProject().getMainBranchComponent();
+ ProjectDto project = db.components().insertPrivateProject().getProjectDto();
logInAsProjectAdministrator(project);
String longName = StringUtils.leftPad("", 60, "a");
String expectedType = StringUtils.leftPad("", 20, "a");
.hasMessageContaining("Project '" + component.uuid() + "' not found");
}
- private void createAndTest(ComponentDto project, String name, String url, String type) {
+ private void createAndTest(ProjectDto project, String name, String url, String type) {
ProjectLinks.CreateWsResponse response = ws.newRequest()
.setMethod("POST")
.setParam(PARAM_PROJECT_KEY, project.getKey())
assertThat(link.getType()).isEqualTo(type);
}
- private void createAndTest(ComponentDto project) {
+ private void createAndTest(ProjectDto project) {
createAndTest(project, "Custom", "http://example.org", "custom");
}
- private void logInAsProjectAdministrator(ComponentDto project) {
+ private void logInAsProjectAdministrator(ProjectDto project) {
userSession.logIn().addProjectPermission(UserRole.ADMIN, project);
}
}
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
private final WsActionTester ws = new WsActionTester(
new RenameAction(db.getDbClient(), new QualityGatesWsSupport(db.getDbClient(), userSession, TestComponentFinder.from(db))));
private final System2 system2 = new AlwaysIncreasingSystem2();
@Rule
- public DbTester db = DbTester.create(system2);
+ public DbTester db = DbTester.create(system2, true);
private final DummyReset reset = new DummyReset();
private final QProfileFactory profileFactory = new DummyProfileFactory();
private final System2 system2 = new AlwaysIncreasingSystem2();
@Rule
- public DbTester db = DbTester.create(system2);
+ public DbTester db = DbTester.create(system2, true);
@Rule
public JUnitTempFolder temp = new JUnitTempFolder();
private final System2 system2 = new AlwaysIncreasingSystem2();
@org.junit.Rule
- public DbTester db = DbTester.create(system2);
+ public DbTester db = DbTester.create(system2, true);
private final RuleFinder ruleFinder = new DefaultRuleFinder(db.getDbClient(), mock(RuleDescriptionFormatter.class));
private final ProfileExporter[] exporters = new ProfileExporter[] {
private System2 system2 = new AlwaysIncreasingSystem2();
@Rule
- public DbTester db = DbTester.create(system2);
+ public DbTester db = DbTester.create(system2, true);
private DbSession dbSession = db.getSession();
private ActiveRuleIndexer activeRuleIndexer = mock(ActiveRuleIndexer.class);
private System2 system2 = new AlwaysIncreasingSystem2();
@Rule
- public DbTester db = DbTester.create(system2);
+ public DbTester db = DbTester.create(system2, true);
@Rule
public EsTester es = EsTester.create();
@Rule
private System2 system2 = new AlwaysIncreasingSystem2();
@Rule
- public DbTester db = DbTester.create(system2);
+ public DbTester db = DbTester.create(system2, true);
@Rule
public EsTester es = EsTester.create();
@Rule
private final System2 system2 = new TestSystem2().setNow(1659510722633L);
@Rule
- public DbTester db = DbTester.create(system2);
+ public DbTester db = DbTester.create(system2, true);
@Rule
public UserSessionRule userSessionRule = UserSessionRule.standalone();
@Rule
private System2 system2 = mock(System2.class);
@Rule
- public DbTester db = DbTester.create(system2);
+ public DbTester db = DbTester.create(system2, true);
@Rule
public UserSessionRule userSessionRule = UserSessionRule.standalone();
@Rule
public class ChangeParentActionIT {
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
@Rule
public EsTester es = EsTester.create();
@Rule
private final TestSystem2 system2 = new TestSystem2().setNow(DateUtils.parseDateTime(DATE).getTime());
@Rule
- public DbTester db = DbTester.create(system2);
+ public DbTester db = DbTester.create(system2, true);
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
private static final String A_LANGUAGE = "xoo";
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
private static final String JAVA_LANGUAGE = "java";
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
public class RenameActionIT {
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
private static final Languages LANGUAGES = new Languages(XOO1, XOO2);
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
private final QualityProfileDbTester qualityProfileDb = db.qualityProfiles();
private final System2 system2 = new TestSystem2().setNow(Instant.now().toEpochMilli());
@Rule
- public DbTester dbTester = DbTester.create(system2);
+ public DbTester dbTester = DbTester.create(system2, true);
@Rule
public EsTester es = EsTester.create();
public UserSessionRule userSessionRule = UserSessionRule.standalone();
@Rule
- public DbTester db = DbTester.create(system2);
+ public DbTester db = DbTester.create(system2, true);
@Rule
public EsTester es = EsTester.create();
private static final Language LANG2 = LanguageTesting.newLanguage("ws", "Whitespace");
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
public UserSessionRule userSession = UserSessionRule.standalone();
@Rule
- public DbTester db = DbTester.create(system2);
+ public DbTester db = DbTester.create(system2, true);
@Rule
public EsTester es = EsTester.create();
private static final String RULE_KEY_2 = "S002";
@Rule
- public DbTester dbTester = DbTester.create(System2.INSTANCE);
+ public DbTester dbTester = DbTester.create(System2.INSTANCE, true);
ListAction underTest = new ListAction(dbTester.getDbClient());
private static final String EMPTY_JSON_RESPONSE = "{\"repositories\":[]}";
@Rule
- public DbTester dbTester = DbTester.create(System2.INSTANCE);
+ public DbTester dbTester = DbTester.create(System2.INSTANCE, true);
private RepositoriesAction underTest = new RepositoriesAction(dbTester.getDbClient());
private WsActionTester tester = new WsActionTester(underTest);
public class RuleQueryFactoryIT {
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
private final System2 system2 = new AlwaysIncreasingSystem2();
@org.junit.Rule
- public DbTester db = DbTester.create(system2);
+ public DbTester db = DbTester.create(system2, true);
@org.junit.Rule
public EsTester es = EsTester.create();
@Rule
public TemporaryFolder temporaryFolder = new TemporaryFolder();
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
private DbClient dbClient = db.getDbClient();
private MapSettings settings = new MapSettings();
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
private final DbClient dbClient = db.getDbClient();
private ProjectDto project;
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
private final I18nRule i18n = new I18nRule();
private final PropertyDbTester propertyDb = new PropertyDbTester(db);
@Rule
public UserSessionRule userSession = UserSessionRule.standalone().logIn();
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
private final PropertyDbTester propertyDb = new PropertyDbTester(db);
private final DbClient dbClient = db.getDbClient();
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
DbClient dbClient = db.getDbClient();
DbSession dbSession = db.getSession();
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
private final DbClient dbClient = db.getDbClient();
private final PropertyDefinitions definitions = new PropertyDefinitions(System2.INSTANCE);
public class IssueSnippetsActionIT {
@Rule
- public final DbTester db = DbTester.create(System2.INSTANCE);
+ public final DbTester db = DbTester.create(System2.INSTANCE, true);
@Rule
public final UserSessionRule userSession = UserSessionRule.standalone();
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
private ResourceTypesRule resourceTypes = new ResourceTypesRule().setRootQualifiers(Qualifiers.PROJECT);
public class ComponentActionIT {
@Rule
- public final DbTester db = DbTester.create(System2.INSTANCE);
+ public final DbTester db = DbTester.create(System2.INSTANCE, true);
@Rule
public final UserSessionRule userSession = UserSessionRule.standalone();
private final System2 system2 = new AlwaysIncreasingSystem2();
@Rule
- public DbTester db = DbTester.create(system2);
+ public DbTester db = DbTester.create(system2, true);
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
private final System2 system2 = new AlwaysIncreasingSystem2();
@Rule
- public DbTester db = DbTester.create(system2);
+ public DbTester db = DbTester.create(system2, true);
@Rule
public UserSessionRule userSessionRule = UserSessionRule.standalone();
private final System2 system2 = new AlwaysIncreasingSystem2();
@Rule
- public DbTester db = DbTester.create(system2);
+ public DbTester db = DbTester.create(system2, true);
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
public class DismissNoticeActionIT {
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
@Rule
public UserSessionRule userSessionRule = UserSessionRule.standalone();
private final System2 system2 = new System2();
@Rule
- public DbTester db = DbTester.create(system2);
+ public DbTester db = DbTester.create(system2, true);
@Rule
public UserSessionRule userSession = UserSessionRule.standalone().logIn().setSystemAdministrator();
private final System2 system2 = new System2();
@Rule
- public DbTester db = DbTester.create(system2);
+ public DbTester db = DbTester.create(system2, true);
@Rule
public UserSessionRule userSession = UserSessionRule.standalone().logIn().setSystemAdministrator();
public class UserAnonymizerIT {
private final System2 system2 = new AlwaysIncreasingSystem2();
@Rule
- public DbTester db = DbTester.create(system2);
+ public DbTester db = DbTester.create(system2, true);
private final UserAnonymizer userAnonymizer = new UserAnonymizer(db.getDbClient());
@Test
public class CreateActionIT {
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
private ManagedInstanceChecker managedInstanceChecker = mock(ManagedInstanceChecker.class);
private static final String EXTERNAL_IDENTITY_PROVIDER = "EXTERNAL_IDENTITY_PROVIDER";
@Rule
- public DbTester dbTester = DbTester.create(System2.INSTANCE);
+ public DbTester dbTester = DbTester.create(System2.INSTANCE, true);
private final DbClient dbClient = dbTester.getDbClient();
private final DbSession dbSession = dbTester.getSession();
private final GroupService groupService = new GroupService(dbClient, UuidFactoryFast.getInstance());
public class SearchActionIT {
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
public class UpdateActionIT {
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
public class UsersActionIT {
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
private static final String TOKEN_NAME = "Third Party Application";
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
public class RevokeActionIT {
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
private DbClient dbClient = db.getDbClient();
private WsActionTester ws = new WsActionTester(new SearchAction(dbClient, new UserTokenSupport(db.getDbClient(), userSession)));
String componentKey = request.getComponent();
if (componentKey != null) {
- Optional<EntityDto> foundComponent;
- foundComponent = dbClient.entityDao().selectByKey(dbSession, componentKey);
- return checkFoundWithOptional(foundComponent, "Component '%s' does not exist", componentKey);
+ Optional<EntityDto> foundEntity;
+ foundEntity = dbClient.entityDao().selectByKey(dbSession, componentKey);
+ return checkFoundWithOptional(foundEntity, "Component '%s' does not exist", componentKey);
} else {
return null;
}
import org.sonar.db.DatabaseUtils;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
+import org.sonar.db.component.BranchDto;
import org.sonar.db.component.ComponentDto;
import org.sonar.db.component.ComponentQuery;
import org.sonar.db.component.ProjectLastAnalysisDateDto;
action.createParam(PARAM_VISIBILITY)
.setDescription("Filter the projects that should be visible to everyone (%s), or only specific user/groups (%s).<br/>" +
- "If no visibility is specified, the default project visibility will be used.",
+ "If no visibility is specified, the default project visibility will be used.",
Visibility.PUBLIC.getLabel(), Visibility.PRIVATE.getLabel())
.setRequired(false)
.setInternal(true)
Paging paging = buildPaging(dbSession, request, query);
List<ComponentDto> components = dbClient.componentDao().selectByQuery(dbSession, query, paging.offset(), paging.pageSize());
Set<String> componentUuids = components.stream().map(ComponentDto::uuid).collect(MoreCollectors.toHashSet(components.size()));
- Map<String, Long> lastAnalysisDateByComponentUuid = dbClient.snapshotDao().selectLastAnalysisDateByProjectUuids(dbSession, componentUuids).stream()
+ List<BranchDto> branchDtos = dbClient.branchDao().selectByUuids(dbSession, componentUuids);
+ Map<String, String> projectUuidByComponentUuid = branchDtos.stream().collect(Collectors.toMap(BranchDto::getUuid,BranchDto::getProjectUuid));
+ Map<String, Long> lastAnalysisDateByComponentUuid = dbClient.snapshotDao().selectLastAnalysisDateByProjectUuids(dbSession, projectUuidByComponentUuid.values()).stream()
.collect(Collectors.toMap(ProjectLastAnalysisDateDto::getProjectUuid, ProjectLastAnalysisDateDto::getDate));
Map<String, SnapshotDto> snapshotsByComponentUuid = dbClient.snapshotDao()
.selectLastAnalysesByRootComponentUuids(dbSession, componentUuids).stream()
.collect(MoreCollectors.uniqueIndex(SnapshotDto::getRootComponentUuid, identity()));
- return buildResponse(components, snapshotsByComponentUuid, lastAnalysisDateByComponentUuid, paging);
+ return buildResponse(components, snapshotsByComponentUuid, lastAnalysisDateByComponentUuid, projectUuidByComponentUuid, paging);
}
}
}
private static SearchWsResponse buildResponse(List<ComponentDto> components, Map<String, SnapshotDto> snapshotsByComponentUuid,
- Map<String, Long> lastAnalysisDateByComponentUuid, Paging paging) {
+ Map<String, Long> lastAnalysisDateByComponentUuid, Map<String, String> projectUuidByComponentUuid, Paging paging) {
SearchWsResponse.Builder responseBuilder = newBuilder();
responseBuilder.getPagingBuilder()
.setPageIndex(paging.pageIndex())
.build();
components.stream()
- .map(dto -> dtoToProject(dto, snapshotsByComponentUuid.get(dto.uuid()), lastAnalysisDateByComponentUuid.get(dto.uuid())))
+ .map(dto -> dtoToProject(dto, snapshotsByComponentUuid.get(dto.uuid()), lastAnalysisDateByComponentUuid.get(projectUuidByComponentUuid.get(dto.uuid()))))
.forEach(responseBuilder::addComponents);
return responseBuilder.build();
}
private static final int WARNING_COUNT = 5;
@Rule
- public DbTester db = DbTester.create(System2.INSTANCE);
+ public DbTester db = DbTester.create(System2.INSTANCE, true);
private final System2 system2 = mock(System2.class);
private final TaskFormatter underTest = new TaskFormatter(db.getDbClient(), system2);
projects / sonarqube.git / commitdiff