ceTask.getComponentUuid()));
}
ComponentDto dto = toProject(reportProjectKey);
- analysisMetadata.setProject(new Project(dto.uuid(), dto.getDbKey(), dto.name(), dto.description()));
+ analysisMetadata.setProject(Project.from(dto));
return () -> {
if (!componentKey.equals(reportProjectKey)) {
throw MessageException.of(format(
import org.sonar.api.ce.posttask.PostProjectAnalysisTask;
import org.sonar.api.measures.Metric;
import org.sonar.core.util.stream.MoreCollectors;
-import org.sonar.server.project.Project;
import org.sonar.server.qualitygate.Condition;
import org.sonar.server.qualitygate.EvaluatedCondition;
import org.sonar.server.qualitygate.EvaluatedQualityGate;
import org.sonar.server.webhook.Analysis;
import org.sonar.server.webhook.Branch;
import org.sonar.server.webhook.CeTask;
+import org.sonar.server.webhook.Project;
import org.sonar.server.webhook.WebHooks;
import org.sonar.server.webhook.WebhookPayloadFactory;
private static org.sonar.server.webhook.ProjectAnalysis convert(ProjectAnalysis projectAnalysis) {
CeTask ceTask = new CeTask(projectAnalysis.getCeTask().getId(), CeTask.Status.valueOf(projectAnalysis.getCeTask().getStatus().name()));
- Project project = new Project(projectAnalysis.getProject().getUuid(), projectAnalysis.getProject().getKey(), projectAnalysis.getProject().getName());
Analysis analysis = projectAnalysis.getAnalysis().map(a -> new Analysis(a.getAnalysisUuid(), a.getDate().getTime())).orElse(null);
Branch branch = projectAnalysis.getBranch().map(b -> new Branch(b.isMain(), b.getName().orElse(null), Branch.Type.valueOf(b.getType().name()))).orElse(null);
EvaluatedQualityGate qualityGate = Optional.ofNullable(projectAnalysis.getQualityGate())
Long date = projectAnalysis.getAnalysis().map(a -> a.getDate().getTime()).orElse(null);
Map<String, String> properties = projectAnalysis.getScannerContext().getProperties();
+ Project project = new Project(projectAnalysis.getProject().getUuid(), projectAnalysis.getProject().getKey(), projectAnalysis.getProject().getName());
return new org.sonar.server.webhook.ProjectAnalysis(project, ceTask, analysis, branch, qualityGate, date, properties);
}
}
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
+import static org.sonar.db.component.ComponentTesting.newPrivateProjectDto;
+import static org.sonar.db.organization.OrganizationTesting.newOrganizationDto;
public class AnalysisMetadataHolderImplTest {
public void set_and_get_project() {
AnalysisMetadataHolderImpl underTest = new AnalysisMetadataHolderImpl();
- Project project = new Project("U", "K", "N");
+ Project project = Project.from(newPrivateProjectDto(newOrganizationDto()));
underTest.setProject(project);
assertThat(underTest.getProject()).isSameAs(project);
@Test
public void setProject_throws_ISE_when_called_twice() {
AnalysisMetadataHolderImpl underTest = new AnalysisMetadataHolderImpl();
- underTest.setProject(new Project("U", "K", "N"));
+ underTest.setProject(Project.from(newPrivateProjectDto(newOrganizationDto())));
expectedException.expect(IllegalStateException.class);
expectedException.expectMessage("Project has already been set");
- underTest.setProject(new Project("U", "K", "N"));
+
+ underTest.setProject(Project.from(newPrivateProjectDto(newOrganizationDto())));
}
@Test
// add main branch in project table and in metadata
ComponentDto dto = ComponentTesting.newPrivateProjectDto(dbTester.organizations().insert(), MAIN.getUuid()).setDbKey(MAIN.getKey());
- analysisMetadataHolder.setProject(new Project(dto.uuid(), dto.getDbKey(), dto.name()));
+ analysisMetadataHolder.setProject(Project.from(dto));
dbTester.getDbClient().componentDao().insert(dbTester.getSession(), dto);
// this should add new columns in project and project_branches
// add main branch in project table and in metadata
ComponentDto dto = ComponentTesting.newPrivateProjectDto(dbTester.organizations().insert(), MAIN.getUuid()).setDbKey(MAIN.getKey());
- analysisMetadataHolder.setProject(new Project(dto.uuid(), dto.getKey(), dto.name(), dto.description()));
+ analysisMetadataHolder.setProject(Project.from(dto));
dbTester.getDbClient().componentDao().insert(dbTester.getSession(), dto);
// this should add new columns in project and project_branches
import org.junit.rules.ExpectedException;
import org.junit.rules.ExternalResource;
import org.mockito.Mockito;
+import org.sonar.ce.task.projectanalysis.analysis.Branch;
import org.sonar.core.component.ComponentKeys;
import org.sonar.db.component.SnapshotDto;
import org.sonar.scanner.protocol.output.ScannerReport;
-import org.sonar.ce.task.projectanalysis.analysis.Branch;
import org.sonar.server.project.Project;
import static com.google.common.base.Preconditions.checkArgument;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.fail;
import static org.mockito.Mockito.when;
+import static org.sonar.ce.task.projectanalysis.component.ComponentVisitor.Order.PRE_ORDER;
+import static org.sonar.db.component.ComponentTesting.newPrivateProjectDto;
+import static org.sonar.db.organization.OrganizationTesting.newOrganizationDto;
+import static org.sonar.scanner.protocol.output.ScannerReport.Component.newBuilder;
import static org.sonar.scanner.protocol.output.ScannerReport.Component.ComponentType.DIRECTORY;
import static org.sonar.scanner.protocol.output.ScannerReport.Component.ComponentType.FILE;
import static org.sonar.scanner.protocol.output.ScannerReport.Component.ComponentType.MODULE;
import static org.sonar.scanner.protocol.output.ScannerReport.Component.ComponentType.PROJECT;
import static org.sonar.scanner.protocol.output.ScannerReport.Component.ComponentType.UNRECOGNIZED;
-import static org.sonar.scanner.protocol.output.ScannerReport.Component.newBuilder;
-import static org.sonar.ce.task.projectanalysis.component.ComponentVisitor.Order.PRE_ORDER;
public class ComponentTreeBuilderTest {
@Rule
public ScannerComponentProvider scannerComponentProvider = new ScannerComponentProvider();
- private Project projectInDb = new Project(UUID_SUPPLIER.apply("K1"), "K1", "theProjectName");
+ private Project projectInDb = Project.from(newPrivateProjectDto(newOrganizationDto(), UUID_SUPPLIER.apply("K1")).setDbKey("K1").setDescription(null));
@Test
public void build_throws_IAE_for_all_types_but_PROJECT_MODULE_DIRECTORY_FILE() {
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
+import static org.sonar.db.component.ComponentTesting.newPrivateProjectDto;
+import static org.sonar.db.organization.OrganizationTesting.newOrganizationDto;
public class ConfigurationRepositoryTest {
- private static Project PROJECT = new Project("UUID", "KEY", "NAME");
+ private static Project PROJECT = Project.from(newPrivateProjectDto(newOrganizationDto()));
@Rule
public final DbTester db = DbTester.create(System2.INSTANCE);
@Test
public void get_project_settings_from_db() {
ComponentDto project = db.components().insertPrivateProject();
- analysisMetadataHolder.setProject(new Project(project.uuid(), project.getDbKey(), project.name()));
+ analysisMetadataHolder.setProject(Project.from(project));
insertProjectProperty(project, "key", "value");
Configuration config = underTest.getConfiguration();
globalSettings.setProperty("key", "value1");
ComponentDto project = db.components().insertPrivateProject();
insertProjectProperty(project, "key", "value2");
- analysisMetadataHolder.setProject(new Project(project.uuid(), project.getDbKey(), project.name()));
+ analysisMetadataHolder.setProject(Project.from(project));
Configuration config = underTest.getConfiguration();
assertThat(config.get("key")).hasValue("value2");
public void project_settings_are_cached_to_avoid_db_access() {
ComponentDto project = db.components().insertPrivateProject();
insertProjectProperty(project, "key", "value");
- analysisMetadataHolder.setProject(new Project(project.uuid(), project.getDbKey(), project.name()));
+ analysisMetadataHolder.setProject(Project.from(project));
Configuration config = underTest.getConfiguration();
assertThat(config.get("key")).hasValue("value");
ComponentDto branchDto = db.components().insertProjectBranch(project);
Branch branch = mock(Branch.class);
when(branch.getName()).thenReturn(branchDto.getBranch());
- analysisMetadataHolder.setProject(new Project(project.uuid(), project.getDbKey(), project.name())).setBranch(branch);
+ analysisMetadataHolder
+ .setProject(Project.from(project))
+ .setBranch(branch);
globalSettings.setProperty("global", "global value");
insertProjectProperty(project, "project", "project value");
insertProjectProperty(branchDto, "branch", "branch value");
import static org.mockito.Mockito.verify;
import static org.sonar.api.measures.CoreMetrics.NCLOC;
import static org.sonar.ce.task.projectanalysis.component.ReportComponent.DUMB_PROJECT;
+import static org.sonar.db.component.ComponentTesting.newPrivateProjectDto;
+import static org.sonar.db.organization.OrganizationTesting.newOrganizationDto;
public class PostMeasuresComputationChecksStepTest {
@Test
public void context_contains_project_uuid_from_analysis_metada_holder() {
- analysisMetadataHolder.setProject(new Project("project_uuid", "project_key", "project_name"));
+ Project project = Project.from(newPrivateProjectDto(newOrganizationDto()));
+ analysisMetadataHolder.setProject(project);
PostMeasuresComputationCheck check = mock(PostMeasuresComputationCheck.class);
newStep(check).execute(new TestComputationStepContext());
ArgumentCaptor<Context> contextArgumentCaptor = ArgumentCaptor.forClass(Context.class);
verify(check).onCheck(contextArgumentCaptor.capture());
- assertThat(contextArgumentCaptor.getValue().getProjectUuid()).isEqualTo("project_uuid");
+ assertThat(contextArgumentCaptor.getValue().getProjectUuid()).isEqualTo(project.getUuid());
}
@Test
import static org.sonar.db.component.ComponentTesting.newModuleDto;
import static org.sonar.db.component.ComponentTesting.newPrivateProjectDto;
import static org.sonar.db.component.SnapshotTesting.newAnalysis;
+import static org.sonar.db.organization.OrganizationTesting.newOrganizationDto;
import static org.sonar.scanner.protocol.output.ScannerReport.Component.ComponentType.DIRECTORY;
import static org.sonar.scanner.protocol.output.ScannerReport.Component.ComponentType.FILE;
import static org.sonar.scanner.protocol.output.ScannerReport.Component.ComponentType.MODULE;
when(branch.generateKey(any(), any())).thenReturn("generated");
analysisMetadataHolder.setRootComponentRef(ROOT_REF)
.setAnalysisDate(ANALYSIS_DATE)
- .setProject(new Project("U1", REPORT_PROJECT_KEY, REPORT_PROJECT_KEY))
+ .setProject(Project.from(newPrivateProjectDto(newOrganizationDto()).setDbKey(REPORT_PROJECT_KEY)))
.setBranch(branch);
BuildComponentTreeStep underTest = new BuildComponentTreeStep(dbClient, reportReader, treeRootHolder, analysisMetadataHolder);
reportReader.putComponent(componentWithKey(ROOT_REF, PROJECT, REPORT_PROJECT_KEY, MODULE_REF));
Branch branch = new DefaultBranchImpl();
analysisMetadataHolder.setRootComponentRef(ROOT_REF)
.setAnalysisDate(ANALYSIS_DATE)
- .setProject(new Project("U1", REPORT_PROJECT_KEY, REPORT_PROJECT_KEY))
+ .setProject(Project.from(newPrivateProjectDto(newOrganizationDto()).setDbKey(REPORT_PROJECT_KEY)))
.setBranch(branch);
BuildComponentTreeStep underTest = new BuildComponentTreeStep(dbClient, reportReader, treeRootHolder, analysisMetadataHolder);
reportReader.putComponent(componentWithKey(ROOT_REF, PROJECT, REPORT_PROJECT_KEY, MODULE_REF));
public void generate_keys_when_using_legacy_branch() {
analysisMetadataHolder.setRootComponentRef(ROOT_REF)
.setAnalysisDate(ANALYSIS_DATE)
- .setProject(new Project("U1", REPORT_PROJECT_KEY, REPORT_PROJECT_KEY))
+ .setProject(Project.from(newPrivateProjectDto(newOrganizationDto()).setDbKey(REPORT_PROJECT_KEY)))
.setBranch(new DefaultBranchImpl("origin/feature"));
BuildComponentTreeStep underTest = new BuildComponentTreeStep(dbClient, reportReader, treeRootHolder, analysisMetadataHolder);
reportReader.putComponent(componentWithKey(ROOT_REF, PROJECT, REPORT_PROJECT_KEY, MODULE_REF));
analysisMetadataHolder.setRootComponentRef(ROOT_REF)
.setAnalysisDate(ANALYSIS_DATE)
.setBranch(new DefaultBranchImpl(null))
- .setProject(new Project("U1", REPORT_PROJECT_KEY, REPORT_PROJECT_KEY));
+ .setProject(Project.from(newPrivateProjectDto(newOrganizationDto()).setDbKey(REPORT_PROJECT_KEY)));
}
}
import org.sonar.db.metric.MetricDto;
import org.sonar.server.project.Project;
+import static java.util.Collections.emptyList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.sonar.ce.task.projectanalysis.component.Component.Type.DIRECTORY;
import static org.sonar.ce.task.projectanalysis.component.Component.Type.FILE;
.build())
.build();
treeRootHolder.setRoot(project);
- analysisMetadataHolder.setProject(new Project(project.getUuid(), project.getKey(), project.getName()));
+ analysisMetadataHolder.setProject(new Project(project.getUuid(), project.getKey(), project.getName(), project.getDescription(), emptyList()));
// components as persisted in db
ComponentDto projectDto = insertComponent("project-key", "project-uuid");
ComponentDto portfolioDto = insertComponent("view-key", "view-uuid");
ComponentDto subViewDto = insertComponent("subview-key", "subview-uuid");
ComponentDto projectDto = insertComponent("project-key", "project-uuid");
- analysisMetadataHolder.setProject(new Project(portfolioDto.uuid(), portfolioDto.getDbKey(), portfolioDto.name()));
+ analysisMetadataHolder.setProject(Project.from(portfolioDto));
}
private void assertThatMeasureIsNotPersisted(String componentUuid, Metric metric) {
import org.sonar.server.notification.NotificationService;
import org.sonar.server.project.Project;
+import static java.util.Collections.emptyList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
@Before
public void setUp() {
when(metricRepository.getByKey(ALERT_STATUS_KEY)).thenReturn(alertStatusMetric);
- analysisMetadataHolder.setProject(new Project(PROJECT_COMPONENT.getUuid(), PROJECT_COMPONENT.getKey(), PROJECT_COMPONENT.getName()));
+ analysisMetadataHolder.setProject(new Project(PROJECT_COMPONENT.getUuid(), PROJECT_COMPONENT.getKey(), PROJECT_COMPONENT.getName(), PROJECT_COMPONENT.getDescription(), emptyList()));
analysisMetadataHolder.setBranch(mock(Branch.class));
treeRootHolder.setRoot(PROJECT_COMPONENT);
}
private ComponentDto prepareProject(Consumer<ComponentDto>... populators) {
ComponentDto dto = db.components().insertPrivateProject(db.organizations().insert(), populators);
- analysisMetadataHolder.setProject(new Project(dto.uuid(), dto.getDbKey(), dto.name()));
+ analysisMetadataHolder.setProject(Project.from(dto));
analysisMetadataHolder.setBranch(new DefaultBranchImpl());
return dto;
}
private ComponentDto prepareBranch(String branchName, Consumer<ComponentDto>... populators) {
ComponentDto dto = db.components().insertPrivateProject(db.organizations().insert(), populators);
- analysisMetadataHolder.setProject(new Project(dto.uuid(), dto.getDbKey(), dto.name()));
+ analysisMetadataHolder.setProject(Project.from(dto));
analysisMetadataHolder.setBranch(new TestBranch(branchName));
return dto;
}
}
verify(payloadFactory).create(new ProjectAnalysis(
- new org.sonar.server.project.Project(project.getUuid(), project.getKey(), project.getName()),
+ new org.sonar.server.webhook.Project(project.getUuid(), project.getKey(), project.getName()),
new org.sonar.server.webhook.CeTask(ceTask.getId(), org.sonar.server.webhook.CeTask.Status.valueOf(ceTask.getStatus().name())),
analysisUUid == null ? null : new Analysis(analysisUUid, date.getTime()),
new org.sonar.server.webhook.Branch(branch.isMain(), branch.getName().get(), org.sonar.server.webhook.Branch.Type.valueOf(branch.getType().name())),
}
/**
- * Select all root components (projects and views), including disabled ones, for a given organization.
+ * Select all projects for a given organization.
*
* Branches are not returned
*/
- public List<ComponentDto> selectAllRootsByOrganization(DbSession dbSession, String organizationUuid) {
- return mapper(dbSession).selectAllRootsByOrganization(organizationUuid);
+ public List<ComponentDto> selectProjectsByOrganization(DbSession dbSession, String organizationUuid) {
+ return mapper(dbSession).selectProjectsByOrganization(organizationUuid);
}
public List<ComponentDto> selectGhostProjects(DbSession session, String organizationUuid, @Nullable String query, int offset, int limit) {
*/
List<ComponentDto> selectProjects();
- List<ComponentDto> selectAllRootsByOrganization(@Param("organizationUuid") String organizationUuid);
+ List<ComponentDto> selectProjectsByOrganization(@Param("organizationUuid") String organizationUuid);
/**
* Return all descendant modules (including itself) from a given component uuid and scope
AND p.main_branch_project_uuid IS NULL
</select>
- <select id="selectAllRootsByOrganization" resultType="Component">
+ <select id="selectProjectsByOrganization" resultType="Component">
select
<include refid="componentColumns"/>
from projects p
where
- p.scope='PRJ'
- and (p.qualifier='TRK' or p.qualifier='VW' or p.qualifier='APP')
+ p.enabled=${_true}
+ and p.scope='PRJ'
+ and p.qualifier='TRK'
and p.organization_uuid = #{organizationUuid,jdbcType=VARCHAR}
and p.main_branch_project_uuid IS NULL
</select>
@DataProvider
public static Object[][] oneOrMoreProjects() {
- return new Object[][]{
+ return new Object[][] {
{1},
{1 + new Random().nextInt(10)}
};
@DataProvider
public static Object[][] portfolioOrApplicationRootViewQualifier() {
- return new Object[][]{
+ return new Object[][] {
{Qualifiers.VIEW},
{Qualifiers.APP},
};
}
@Test
- public void select_all_roots_by_organization() {
+ public void select_projects_by_organization() {
OrganizationDto organization = db.organizations().insert();
ComponentDto project1 = db.components().insertPrivateProject(organization);
ComponentDto module = db.components().insertComponent(newModuleDto(project1));
OrganizationDto otherOrganization = db.organizations().insert();
ComponentDto projectOnOtherOrganization = db.components().insertPrivateProject(otherOrganization);
- assertThat(underTest.selectAllRootsByOrganization(dbSession, organization.getUuid()))
+ assertThat(underTest.selectProjectsByOrganization(dbSession, organization.getUuid()))
.extracting(ComponentDto::uuid)
- .containsExactlyInAnyOrder(project1.uuid(), project2.uuid(), view.uuid(), application.uuid());
+ .containsExactlyInAnyOrder(project1.uuid(), project2.uuid())
+ .doesNotContain(view.uuid(), application.uuid());
}
@Test
- public void select_all_roots_by_organization_does_not_return_branches() {
+ public void select_projects_by_organization_does_not_return_branches() {
OrganizationDto organization = db.organizations().insert();
ComponentDto project = db.components().insertMainBranch(organization);
ComponentDto branch = db.components().insertProjectBranch(project);
- assertThat(underTest.selectAllRootsByOrganization(dbSession, organization.getUuid()))
+ assertThat(underTest.selectProjectsByOrganization(dbSession, organization.getUuid()))
.extracting(ComponentDto::uuid)
.containsExactlyInAnyOrder(project.uuid())
.doesNotContain(branch.uuid());
underTest.countByQuery(dbSession, query.build());
}
-
@Test
public void countByNclocRanges_on_zero_projects() {
db.measures().insertMetric(m -> m.setKey(CoreMetrics.NCLOC_KEY));
tuple("1M", 0L),
tuple("+1M", 0L));
}
- @Test
+
+ @Test
public void countByNclocRanges() {
MetricDto ncloc = db.measures().insertMetric(m -> m.setKey(CoreMetrics.NCLOC_KEY));
import java.util.Collection;
import java.util.Date;
import java.util.HashSet;
-import java.util.Locale;
import java.util.Objects;
import java.util.Set;
import javax.annotation.Nullable;
import org.sonar.core.issue.DefaultIssue;
import org.sonar.core.issue.DefaultIssueComment;
import org.sonar.core.issue.IssueChangeContext;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.user.UserDto;
import static com.google.common.base.Preconditions.checkState;
}
public boolean setTags(DefaultIssue issue, Collection<String> tags, IssueChangeContext context) {
- Set<String> newTags = tags.stream()
- .filter(Objects::nonNull)
- .filter(tag -> !tag.isEmpty())
- .map(tag -> RuleTagFormat.validate(tag.toLowerCase(Locale.ENGLISH)))
- .collect(MoreCollectors.toSet());
+ Set<String> newTags = RuleTagFormat.validate(tags);
Set<String> oldTags = new HashSet<>(issue.tags());
if (!oldTags.equals(newTags)) {
*/
package org.sonar.server.project;
+import java.util.List;
import java.util.Objects;
import javax.annotation.Nullable;
import javax.annotation.concurrent.Immutable;
private final String key;
private final String name;
private final String description;
+ private final List<String> tags;
- public Project(String uuid, String key, String name) {
- this(uuid, key, name, null);
- }
-
- public Project(String uuid, String key, String name, @Nullable String description) {
+ public Project(String uuid, String key, String name, @Nullable String description, List<String> tags) {
this.uuid = uuid;
this.key = key;
this.name = name;
this.description = description;
+ this.tags = tags;
}
public static Project from(ComponentDto project) {
- return new Project(project.uuid(), project.getDbKey(), project.name(), project.description());
+ return new Project(project.uuid(), project.getKey(), project.name(), project.description(), project.getTags());
}
/**
return description;
}
+ public List<String> getTags() {
+ return tags;
+ }
+
@Override
public boolean equals(Object o) {
if (this == o) {
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2018 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+package org.sonar.server.webhook;
+
+import java.util.Objects;
+import javax.annotation.concurrent.Immutable;
+
+@Immutable
+public class Project {
+
+ private final String uuid;
+ private final String key;
+ private final String name;
+
+ public Project(String uuid, String key, String name) {
+ this.uuid = uuid;
+ this.key = key;
+ this.name = name;
+ }
+
+ public String getUuid() {
+ return uuid;
+ }
+
+ public String getKey() {
+ return key;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (o == null || getClass() != o.getClass()) {
+ return false;
+ }
+ Project project = (Project) o;
+ return Objects.equals(uuid, project.uuid) &&
+ Objects.equals(key, project.key) &&
+ Objects.equals(name, project.name);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(uuid, key, name);
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder("Project{");
+ sb.append("uuid='").append(uuid).append('\'');
+ sb.append(", key='").append(key).append('\'');
+ sb.append(", name='").append(name).append('\'');
+ sb.append('}');
+ return sb.toString();
+ }
+
+}
import java.util.Objects;
import java.util.Optional;
import javax.annotation.Nullable;
-import org.sonar.server.project.Project;
import org.sonar.server.qualitygate.EvaluatedQualityGate;
import static com.google.common.collect.ImmutableMap.copyOf;
import org.sonar.api.server.ServerSide;
import org.sonar.api.utils.System2;
import org.sonar.api.utils.text.JsonWriter;
-import org.sonar.server.project.Project;
import org.sonar.server.qualitygate.Condition;
import org.sonar.server.qualitygate.EvaluatedCondition;
import org.sonar.server.qualitygate.EvaluatedQualityGate;
import org.junit.Test;
+import static java.util.Collections.emptyList;
import static org.assertj.core.api.Assertions.assertThat;
public class ProjectTest {
@Test
public void test_bean_without_description() {
- Project project1 = new Project("U1", "K1", "N1");
- Project project2 = new Project("U1", "K1", "N1", null);
+ Project project1 = new Project("U1", "K1", "N1", null, emptyList());
+ Project project2 = new Project("U1", "K1", "N1", null, emptyList());
assertThat(project1.getUuid()).isEqualTo(project2.getUuid()).isEqualTo("U1");
assertThat(project1.getKey()).isEqualTo(project2.getKey()).isEqualTo("K1");
@Test
public void test_bean_with_description() {
- Project project1 = new Project("U1", "K1", "N1", "D1");
+ Project project1 = new Project("U1", "K1", "N1", "D1", emptyList());
assertThat(project1.getUuid()).isEqualTo("U1");
assertThat(project1.getKey()).isEqualTo("K1");
@Test
public void test_equals_and_hashCode() {
- Project project1 = new Project("U1", "K1", "N1");
- Project project2 = new Project("U1", "K1", "N1", "D1");
+ Project project1 = new Project("U1", "K1", "N1", null, emptyList());
+ Project project2 = new Project("U1", "K1", "N1", "D1", emptyList());
assertThat(project1).isEqualTo(project1);
assertThat(project1).isNotEqualTo(null);
assertThat(project1).isNotEqualTo(new Object());
- assertThat(project1).isEqualTo(new Project("U1", "K1", "N1", null));
- assertThat(project1).isNotEqualTo(new Project("U1", "K2", "N1", null));
- assertThat(project1).isNotEqualTo(new Project("U1", "K1", "N2", null));
+ assertThat(project1).isEqualTo(new Project("U1", "K1", "N1", null, emptyList()));
+ assertThat(project1).isNotEqualTo(new Project("U1", "K2", "N1", null, emptyList()));
+ assertThat(project1).isNotEqualTo(new Project("U1", "K1", "N2", null, emptyList()));
assertThat(project1).isEqualTo(project2);
assertThat(project1.hashCode()).isEqualTo(project1.hashCode());
assertThat(project1.hashCode()).isNotEqualTo(null);
assertThat(project1.hashCode()).isNotEqualTo(new Object().hashCode());
- assertThat(project1.hashCode()).isEqualTo(new Project("U1", "K1", "N1", null).hashCode());
- assertThat(project1.hashCode()).isNotEqualTo(new Project("U1", "K2", "N1", null).hashCode());
- assertThat(project1.hashCode()).isNotEqualTo(new Project("U1", "K1", "N2", null).hashCode());
+ assertThat(project1.hashCode()).isEqualTo(new Project("U1", "K1", "N1", null, emptyList()).hashCode());
+ assertThat(project1.hashCode()).isNotEqualTo(new Project("U1", "K2", "N1", null, emptyList()).hashCode());
+ assertThat(project1.hashCode()).isNotEqualTo(new Project("U1", "K1", "N2", null, emptyList()).hashCode());
assertThat(project1.hashCode()).isEqualTo(project2.hashCode());
}
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.sonar.api.measures.Metric;
-import org.sonar.server.project.Project;
import org.sonar.server.qualitygate.EvaluatedQualityGate;
import org.sonar.server.qualitygate.QualityGate;
@Test
public void verify_toString() {
assertThat(underTest.toString()).isEqualTo(
- "ProjectAnalysis{project=Project{uuid='uuid', key='key', name='name', description=null}, ceTask=CeTask{id='id', status=SUCCESS}, branch=Branch{main=true, name='name', type=SHORT}, qualityGate=EvaluatedQualityGate{qualityGate=QualityGate{id=id, name='name', conditions=[]}, status=WARN, evaluatedConditions=[]}, updatedAt=1, properties={a=b}, analysis=Analysis{uuid='analysis_uuid', date=1500}}");
+ "ProjectAnalysis{project=Project{uuid='uuid', key='key', name='name'}, ceTask=CeTask{id='id', status=SUCCESS}, branch=Branch{main=true, name='name', type=SHORT}, qualityGate=EvaluatedQualityGate{qualityGate=QualityGate{id=id, name='name', conditions=[]}, status=WARN, evaluatedConditions=[]}, updatedAt=1, properties={a=b}, analysis=Analysis{uuid='analysis_uuid', date=1500}}");
}
}
import org.sonar.api.measures.Metric;
import org.sonar.api.platform.Server;
import org.sonar.api.utils.System2;
-import org.sonar.server.project.Project;
import org.sonar.server.qualitygate.Condition;
import org.sonar.server.qualitygate.EvaluatedCondition;
import org.sonar.server.qualitygate.EvaluatedQualityGate;
import org.sonar.server.project.RekeyedProject;
import org.sonar.server.user.UserSession;
+import static java.util.Collections.emptyList;
import static java.util.Collections.singleton;
import static java.util.Collections.singletonList;
import static org.sonar.core.component.ComponentKeys.isValidModuleKey;
dbClient.componentKeyUpdaterDao().updateKey(dbSession, projectOrModule.uuid(), newKey);
projectIndexers.commitAndIndex(dbSession, singletonList(projectOrModule), ProjectIndexer.Cause.PROJECT_KEY_UPDATE);
if (isMainProject(projectOrModule)) {
- Project newProject = new Project(projectOrModule.uuid(), newKey, projectOrModule.name(), projectOrModule.description());
+ Project newProject = new Project(projectOrModule.uuid(), newKey, projectOrModule.name(), projectOrModule.description(), projectOrModule.getTags());
projectLifeCycleListeners.onProjectsRekeyed(singleton(new RekeyedProject(newProject, projectOrModule.getDbKey())));
}
}
private static RekeyedProject toRekeyedProject(ComponentKeyUpdaterDao.RekeyedResource rekeyedResource) {
ResourceDto resource = rekeyedResource.getResource();
- Project project = new Project(resource.getUuid(), resource.getKey(), resource.getName(), resource.getDescription());
+ Project project = new Project(resource.getUuid(), resource.getKey(), resource.getName(), resource.getDescription(), emptyList());
return new RekeyedProject(project, rekeyedResource.getOldKey());
}
}
private void deleteProjects(DbSession dbSession, OrganizationDto organization) {
- List<ComponentDto> roots = dbClient.componentDao().selectAllRootsByOrganization(dbSession, organization.getUuid());
+ List<ComponentDto> roots = dbClient.componentDao().selectProjectsByOrganization(dbSession, organization.getUuid());
try {
componentCleanerService.delete(dbSession, roots);
} finally {
import org.sonar.db.component.BranchDto;
import org.sonar.db.component.ComponentDto;
import org.sonar.db.component.SnapshotDto;
-import org.sonar.server.project.Project;
import org.sonar.server.qualitygate.EvaluatedQualityGate;
import org.sonar.server.qualitygate.changeevent.QGChangeEvent;
import org.sonar.server.qualitygate.changeevent.QGChangeEventListener;
import org.sonar.server.project.RekeyedProject;
import org.sonar.server.tester.UserSessionRule;
+import static java.util.Collections.emptyList;
import static org.assertj.guava.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
assertComponentKeyUpdated(inactiveModule.getDbKey(), "your_project:root:inactive_module");
assertComponentKeyUpdated(inactiveFile.getDbKey(), "your_project:root:module:src/InactiveFile.xoo");
verify(projectLifeCycleListeners).onProjectsRekeyed(ImmutableSet.of(
- new RekeyedProject(new Project(project.uuid(), "your_project", project.name(), project.uuid()), "my_project")
+ new RekeyedProject(new Project(project.uuid(), "your_project", project.name(), project.uuid(), emptyList()), "my_project")
));
}
assertComponentKeyUpdated(module.getDbKey(), "your_project:root:module");
assertComponentKeyUpdated(file.getDbKey(), "your_project:root:module:src/File.xoo");
verify(projectLifeCycleListeners).onProjectsRekeyed(ImmutableSet.of(
- new RekeyedProject(new Project(project.uuid(), "your_project", project.name(), project.uuid()), "my_project")
+ new RekeyedProject(new Project(project.uuid(), "your_project", project.name(), project.uuid(), emptyList()), "my_project")
));
}
import org.sonar.server.exceptions.UnauthorizedException;
import org.sonar.server.issue.IssueFieldsSetter;
import org.sonar.server.issue.IssueFinder;
-import org.sonar.server.issue.WebIssueStorage;
import org.sonar.server.issue.IssueUpdater;
import org.sonar.server.issue.TestIssueChangePostProcessor;
+import org.sonar.server.issue.WebIssueStorage;
import org.sonar.server.issue.index.IssueIndexer;
import org.sonar.server.issue.index.IssueIteratorFactory;
import org.sonar.server.notification.NotificationManager;
}
@Test
- public void fail_when_bad_tag_format() {
+ public void fail_when_tag_use_bad_format() {
IssueDto issueDto = db.issues().insertIssue(newIssue().setTags(singletonList("old-tag")));
logIn(issueDto);
expectedException.expect(IllegalArgumentException.class);
- expectedException.expectMessage("Tag 'pol op' is invalid. Rule tags accept only the characters: a-z, 0-9, '+', '-', '#', '.'");
+ expectedException.expectMessage("Tags 'pol op' are invalid. Rule tags accept only the characters: a-z, 0-9, '+', '-', '#', '.'");
call(issueDto.getKey(), "pol op");
}
ComponentDto module = db.components().insertComponent(ComponentTesting.newModuleDto(project));
ComponentDto directory = db.components().insertComponent(ComponentTesting.newDirectory(module, "a/b" + i));
ComponentDto file = db.components().insertComponent(ComponentTesting.newFileDto(module, directory));
- ComponentDto view = db.components().insertView(organization);
- ComponentDto subview1 = db.components().insertComponent(ComponentTesting.newSubView(view, "v1" + i, "ksv1" + i));
- ComponentDto subview2 = db.components().insertComponent(ComponentTesting.newSubView(subview1, "v2" + i, "ksv2" + i));
- ComponentDto application = db.components().insertApplication(organization);
- ComponentDto projectCopy = db.components().insertComponent(ComponentTesting.newProjectCopy("pc1" + i, project, subview1));
- ComponentDto projectCopyForApplication = db.components().insertComponent(ComponentTesting.newProjectCopy("pc2" + i, project, application));
ComponentDto branch = db.components().insertProjectBranch(project);
return project;
}).collect(toSet());
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.sonar.db.component.ComponentTesting.newPrivateProjectDto;
+import static org.sonar.db.organization.OrganizationTesting.newOrganizationDto;
@RunWith(DataProviderRunner.class)
public class ProjectLifeCycleListenersImplTest {
inOrder.verifyNoMoreInteractions();
}
-
@DataProvider
public static Object[][] oneOrManyProjects() {
return new Object[][] {
};
}
- private static int counter = 3_989;
-
private static Project newUniqueProject() {
- int base = counter++;
- return new Project(base + "_uuid", base + "_key", base + "_name");
+ return Project.from(newPrivateProjectDto(newOrganizationDto()));
}
+ private static int counter = 3_989;
+
private static RekeyedProject newUniqueRekeyedProject() {
int base = counter++;
- Project project = new Project(base + "_uuid", base + "_key", base + "_name");
+ Project project = Project.from(newPrivateProjectDto(newOrganizationDto()));
return new RekeyedProject(project, base + "_old_key");
}
}
import org.junit.Test;
import org.junit.rules.ExpectedException;
+import static java.util.Collections.emptyList;
import static org.apache.commons.lang.RandomStringUtils.randomAlphanumeric;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.sonar.db.component.ComponentTesting.newPrivateProjectDto;
+import static org.sonar.db.organization.OrganizationTesting.newOrganizationDto;
public class RekeyedProjectTest {
@Rule
@Test
public void verify_toString() {
- Project project = new Project("A", "B", "C", "D");
+ Project project = new Project("A", "B", "C", "D", emptyList());
String previousKey = "E";
RekeyedProject underTest = new RekeyedProject(project, previousKey);
}
private static Project newRandomProject() {
- return new Project(randomAlphanumeric(3), randomAlphanumeric(4), randomAlphanumeric(5));
+ return Project.from(newPrivateProjectDto(newOrganizationDto()));
}
}
import org.sonar.db.component.ComponentDto;
import org.sonar.db.component.SnapshotDto;
import org.sonar.db.organization.OrganizationDto;
-import org.sonar.server.project.Project;
import org.sonar.server.qualitygate.EvaluatedQualityGate;
import org.sonar.server.qualitygate.changeevent.QGChangeEvent;
import org.sonar.server.qualitygate.changeevent.QGChangeEventListener;
@DataProvider
public static Object[][] newQGorNot() {
EvaluatedQualityGate newQualityGate = mock(EvaluatedQualityGate.class);
- return new Object[][]{
+ return new Object[][] {
{null},
{newQualityGate}
};
*/
package org.sonar.api.server.rule;
+import java.util.Collection;
+import java.util.Objects;
+import java.util.Set;
import org.apache.commons.lang.StringUtils;
+import static java.lang.String.format;
+import static java.lang.String.join;
+import static java.util.Locale.ENGLISH;
+import static java.util.stream.Collectors.toSet;
+
/**
* The characters allowed in rule tags are the same as those on StackOverflow, basically lower-case
* letters, digits, plus (+), sharp (#), dash (-) and dot (.)
*/
public class RuleTagFormat {
+ private static final String ERROR_MESSAGE_SUFFIX = "Rule tags accept only the characters: a-z, 0-9, '+', '-', '#', '.'";
+
private static final String VALID_CHARACTERS_REGEX = "^[a-z0-9\\+#\\-\\.]+$";
private RuleTagFormat() {
public static String validate(String tag) {
if (!isValid(tag)) {
- throw new IllegalArgumentException(String.format("Tag '%s' is invalid. Rule tags accept only the characters: a-z, 0-9, '+', '-', '#', '.'", tag));
+ throw new IllegalArgumentException(format("Tag '%s' is invalid. %s", tag, ERROR_MESSAGE_SUFFIX));
}
return tag;
}
+
+ public static Set<String> validate(Collection<String> tags) {
+ Set<String> sanitizedTags = tags.stream()
+ .filter(Objects::nonNull)
+ .filter(tag -> !tag.isEmpty())
+ .map(tag -> tag.toLowerCase(ENGLISH))
+ .collect(toSet());
+ Set<String> invalidTags = sanitizedTags.stream()
+ .filter(tag -> !isValid(tag))
+ .collect(toSet());
+ if (invalidTags.isEmpty()) {
+ return sanitizedTags;
+ }
+ throw new IllegalArgumentException(format("Tags '%s' are invalid. %s", join(", ", invalidTags), ERROR_MESSAGE_SUFFIX));
+ }
+
}
*/
package org.sonar.api.server.rule;
+import java.util.Collections;
import org.junit.Test;
+import static java.util.Arrays.asList;
+import static java.util.Collections.singletonList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.fail;
public class RuleTagFormatTest {
+
@Test
public void isValid() {
assertThat(RuleTagFormat.isValid(null)).isFalse();
assertThat(e).hasMessage("Tag ' ' is invalid. Rule tags accept only the characters: a-z, 0-9, '+', '-', '#', '.'");
}
}
+
+ @Test
+ public void validate_and_sanitize_collection_of_tags() {
+ assertThat(RuleTagFormat.validate(asList("style", "coding-style", ""))).containsExactly("coding-style", "style");
+ assertThat(RuleTagFormat.validate(asList("style", "coding-style", null))).containsExactly("coding-style", "style");
+ assertThat(RuleTagFormat.validate(asList("style", "style", null))).containsExactly("style");
+ assertThat(RuleTagFormat.validate(singletonList("Uppercase"))).containsExactly("uppercase");
+ assertThat(RuleTagFormat.validate(Collections.emptyList())).isEmpty();
+ }
+
+ @Test
+ public void fail_to_validate_collection_of_tags() {
+ try {
+ RuleTagFormat.validate(asList("coding style", "Stylé", "valid"));
+ fail();
+ } catch (IllegalArgumentException e) {
+ assertThat(e).hasMessage("Tags 'coding style, stylé' are invalid. Rule tags accept only the characters: a-z, 0-9, '+', '-', '#', '.'");
+ }
+ }
}
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2018 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+package org.sonarqube.ws.client.views;
+
+import java.util.List;
+import javax.annotation.Generated;
+
+/**
+ * This is part of the internal API.
+ * This is a POST request.
+ * @see <a href="https://next.sonarqube.com/sonarqube/web_api/api/views/set_tags_mode">Further information about this action online (including a response example)</a>
+ * @since 7.4
+ */
+@Generated("sonar-ws-generator")
+public class SetTagsModeRequest {
+
+ private String portfolio;
+ private List<String> tags;
+
+ /**
+ * This is a mandatory parameter.
+ */
+ public SetTagsModeRequest setPortfolio(String portfolio) {
+ this.portfolio = portfolio;
+ return this;
+ }
+
+ public String getPortfolio() {
+ return portfolio;
+ }
+
+ /**
+ * This is a mandatory parameter.
+ */
+ public SetTagsModeRequest setTags(List<String> tags) {
+ this.tags = tags;
+ return this;
+ }
+
+ public List<String> getTags() {
+ return tags;
+ }
+}
*/
package org.sonarqube.ws.client.views;
+import java.util.stream.Collectors;
import javax.annotation.Generated;
import org.sonarqube.ws.MediaTypes;
import org.sonarqube.ws.client.BaseService;
).content();
}
+ /**
+ *
+ * This is part of the internal API.
+ * This is a POST request.
+ * @see <a href="https://next.sonarqube.com/sonarqube/web_api/api/views/set_tags_mode">Further information about this action online (including a response example)</a>
+ * @since 7.4
+ */
+ public void setTagsMode(SetTagsModeRequest request) {
+ call(
+ new PostRequest(path("set_tags_mode"))
+ .setParam("portfolio", request.getPortfolio())
+ .setParam("tags", request.getTags() == null ? null : request.getTags().stream().collect(Collectors.joining(",")))
+ .setMediaType(MediaTypes.JSON)
+ ).content();
+ }
+
/**
*
* This is part of the internal API.
projects / sonarqube.git / commitdiff