* Populates the {@link PeriodHolder}
* <p/>
* Here is how these periods are computed :
- * - Read the period property ${@link org.sonar.core.config.CorePropertyDefinitions#LEAK_PERIOD}
- * - Try to find the matching snapshots from the property
+ * - Read the new code period from DB
+ * - Try to find the matching snapshots from the setting
* - If a snapshot is found, a period is set to the repository, otherwise fail with MessageException
*/
public class LoadPeriodsStep implements ComputationStep {
import org.sonar.db.component.ComponentDto;
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.property.PropertyTesting.newComponentPropertyDto;
public class ProjectConfigurationFactoryTest {
assertThat(projectConfig.get("key")).hasValue("value2");
}
-
- @Test
- public void branch_settings() {
- ComponentDto project = db.components().insertMainBranch();
- ComponentDto branch = db.components().insertProjectBranch(project);
- db.properties().insertProperties(newComponentPropertyDto(branch).setKey("sonar.leak.period").setValue("1"));
-
- Configuration config = underTest.newProjectConfiguration(project.getKey(), createBranch(branch.getBranch(), false));
-
- assertThat(config.get("sonar.leak.period")).hasValue("1");
- }
-
- @Test
- public void branch_settings_contains_global_settings() {
- settings.setProperty("global", "global_value");
- ComponentDto project = db.components().insertMainBranch();
- ComponentDto branch = db.components().insertProjectBranch(project);
- db.properties().insertProperties(newComponentPropertyDto(branch).setKey("sonar.leak.period").setValue("1"));
-
- Configuration config = underTest.newProjectConfiguration(project.getKey(), createBranch(branch.getBranch(), false));
-
- assertThat(config.get("global")).hasValue("global_value");
- assertThat(config.get("sonar.leak.period")).hasValue("1");
- }
-
- @Test
- public void branch_settings_contains_project_settings() {
- ComponentDto project = db.components().insertMainBranch();
- db.properties().insertProperties(newComponentPropertyDto(project).setKey("key").setValue("value"));
- ComponentDto branch = db.components().insertProjectBranch(project);
- db.properties().insertProperties(newComponentPropertyDto(branch).setKey("sonar.leak.period").setValue("1"));
-
- Configuration config = underTest.newProjectConfiguration(project.getKey(), createBranch(branch.getBranch(), false));
-
- assertThat(config.get("key")).hasValue("value");
- assertThat(config.get("sonar.leak.period")).hasValue("1");
- }
-
- @Test
- public void branch_settings_override_project_settings() {
- ComponentDto project = db.components().insertMainBranch();
- db.properties().insertProperties(newComponentPropertyDto(project).setKey("sonar.leak.period").setValue("1"));
- ComponentDto branch = db.components().insertProjectBranch(project);
- db.properties().insertProperties(newComponentPropertyDto(branch).setKey("sonar.leak.period").setValue("2"));
-
- Configuration config = underTest.newProjectConfiguration(project.getKey(), createBranch(branch.getBranch(), false));
-
- assertThat(config.get("sonar.leak.period")).hasValue("2");
- }
-
- @Test
- public void main_branch() {
- ComponentDto project = db.components().insertMainBranch();
- db.properties().insertProperties(newComponentPropertyDto(project).setKey("sonar.leak.period").setValue("1"));
- Branch branch = createBranch("master", true);
- when(branch.isMain()).thenReturn(true);
-
- Configuration config = underTest.newProjectConfiguration(project.getKey(), createBranch(branch.getName(), true));
-
- assertThat(config.get("sonar.leak.period")).hasValue("1");
- }
-
- private static Branch createBranch(String name, boolean isMain) {
- Branch branch = mock(Branch.class);
- when(branch.getName()).thenReturn(name);
- when(branch.isMain()).thenReturn(isMain);
- return branch;
- }
}
import org.sonar.ce.task.projectanalysis.analysis.AnalysisMetadataHolderRule;
import org.sonar.ce.task.projectanalysis.analysis.Branch;
import org.sonar.ce.task.projectanalysis.component.Component;
-import org.sonar.ce.task.projectanalysis.component.DefaultBranchImpl;
import org.sonar.ce.task.projectanalysis.component.ReportComponent;
import org.sonar.ce.task.projectanalysis.measure.Measure;
import org.sonar.ce.task.projectanalysis.measure.MeasureRepositoryRule;
import static org.sonar.api.rules.RuleType.BUG;
import static org.sonar.api.rules.RuleType.CODE_SMELL;
import static org.sonar.api.rules.RuleType.VULNERABILITY;
-import static org.sonar.core.config.CorePropertyDefinitions.LEAK_PERIOD_MODE_PREVIOUS_VERSION;
public class NewEffortAggregatorTest {
private static final Period PERIOD = new Period(NewCodePeriodType.PREVIOUS_VERSION.name(), null, 1_500_000_000L);
- private static final long[] OLD_ISSUES_DATES = new long[] {
+ private static final long[] OLD_ISSUES_DATES = new long[]{
PERIOD.getSnapshotDate(),
PERIOD.getSnapshotDate() - 1,
PERIOD.getSnapshotDate() - 1_200_000L,
import org.sonar.db.newcodeperiod.NewCodePeriodType;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.sonar.core.config.CorePropertyDefinitions.LEAK_PERIOD_MODE_VERSION;
public class PeriodTest {
dbTester.events().insertEvent(newEvent(analysis).setName("0.9").setCategory(CATEGORY_VERSION));
setupRoot(project, "1.1");
- //settings.setProperty("sonar.leak.period", "previous_version");
+ dbTester.newCodePeriods().insert(NewCodePeriodType.PREVIOUS_VERSION, null);
+
underTest.execute(new TestComputationStepContext());
assertPeriod(NewCodePeriodType.PREVIOUS_VERSION, null, analysis.getCreatedAt());
@Test
@UseDataProvider("anyValidLeakPeriodSettingValue")
- public void leak_period_setting_is_ignored_for_SLB_or_PR(String leakPeriodSettingValue) {
+ public void leak_period_setting_is_ignored_for_SLB_or_PR(NewCodePeriodType type, @Nullable String value) {
when(analysisMetadataHolder.isLongLivingBranch()).thenReturn(false);
- //settings.setProperty("sonar.leak.period", leakPeriodSettingValue);
+ dbTester.newCodePeriods().insert(type, value);
+
underTest.execute(new TestComputationStepContext());
assertThat(periodsHolder.hasPeriod()).isFalse();
public static Object[][] anyValidLeakPeriodSettingValue() {
return new Object[][]{
// days
- {"100"},
- // previous_version keyword
- {"previous_version"}
+ {NewCodePeriodType.NUMBER_OF_DAYS, "100"},
+ // previous_version
+ {NewCodePeriodType.PREVIOUS_VERSION, null}
};
}
}
@Test
- public void measures_on_leak_period_are_persisted() {
+ public void measures_on_new_code_period_are_persisted() {
prepareProject();
measureRepository.addRawMeasure(REF_1, INT_METRIC.getKey(), newMeasureBuilder().setVariation(42.0).createNoValue());
}
@Test
- public void measures_on_leak_period_are_persisted() {
+ public void measures_on_new_code_period_are_persisted() {
prepareProject();
measureRepository.addRawMeasure(REF_1, INT_METRIC.getKey(), newMeasureBuilder().setVariation(42.0).createNoValue());
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-import static org.sonar.core.config.CorePropertyDefinitions.LEAK_PERIOD_MODE_DATE;
-import static org.sonar.core.config.CorePropertyDefinitions.LEAK_PERIOD_MODE_PREVIOUS_VERSION;
public class ReportPersistAnalysisStepTest extends BaseStepTest {
}
@Test
- public void persist_snapshots_with_leak_period() {
+ public void persist_snapshots_with_new_code_period() {
OrganizationDto organizationDto = dbTester.organizations().insert();
ComponentDto projectDto = ComponentTesting.newPrivateProjectDto(organizationDto, "ABCD").setDbKey(PROJECT_KEY).setName("Project");
dbClient.componentDao().insert(dbTester.getSession(), projectDto);
SnapshotDto snapshotDto = SnapshotTesting.newAnalysis(projectDto).setCreatedAt(DateUtils.parseDateQuietly("2015-01-01").getTime());
dbClient.snapshotDao().insert(dbTester.getSession(), snapshotDto);
dbTester.getSession().commit();
- periodsHolder.setPeriod(new Period(LEAK_PERIOD_MODE_DATE, "2015-01-01", analysisDate));
+ periodsHolder.setPeriod(new Period("NUMBER_OF_DAYS", "10", analysisDate));
Component project = ReportComponent.builder(Component.Type.PROJECT, 1).setUuid("ABCD").setKey(PROJECT_KEY).build();
treeRootHolder.setRoot(project);
underTest.execute(new TestComputationStepContext());
SnapshotDto projectSnapshot = getUnprocessedSnapshot(projectDto.uuid());
- assertThat(projectSnapshot.getPeriodMode()).isEqualTo(LEAK_PERIOD_MODE_DATE);
+ assertThat(projectSnapshot.getPeriodMode()).isEqualTo("NUMBER_OF_DAYS");
assertThat(projectSnapshot.getPeriodDate()).isEqualTo(analysisDate);
assertThat(projectSnapshot.getPeriodModeParameter()).isNotNull();
}
@Test
- public void only_persist_snapshots_with_leak_period_on_project_and_module() {
- periodsHolder.setPeriod(new Period(LEAK_PERIOD_MODE_PREVIOUS_VERSION, null, analysisDate));
+ public void only_persist_snapshots_with_new_code_period_on_project_and_module() {
+ periodsHolder.setPeriod(new Period("PREVIOUS_VERSION", null, analysisDate));
OrganizationDto organizationDto = dbTester.organizations().insert();
ComponentDto projectDto = ComponentTesting.newPrivateProjectDto(organizationDto, "ABCD").setDbKey(PROJECT_KEY).setName("Project");
underTest.execute(new TestComputationStepContext());
SnapshotDto newProjectSnapshot = getUnprocessedSnapshot(projectDto.uuid());
- assertThat(newProjectSnapshot.getPeriodMode()).isEqualTo(LEAK_PERIOD_MODE_PREVIOUS_VERSION);
+ assertThat(newProjectSnapshot.getPeriodMode()).isEqualTo("PREVIOUS_VERSION");
}
@Test
import static org.sonar.ce.task.projectanalysis.component.Component.Type.PROJECT_VIEW;
import static org.sonar.ce.task.projectanalysis.component.Component.Type.SUBVIEW;
import static org.sonar.ce.task.projectanalysis.component.Component.Type.VIEW;
-import static org.sonar.core.config.CorePropertyDefinitions.LEAK_PERIOD_MODE_DATE;
import static org.sonar.db.component.ComponentTesting.newPrivateProjectDto;
import static org.sonar.db.component.ComponentTesting.newSubView;
import static org.sonar.db.component.ComponentTesting.newView;
}
@Test
- public void persist_snapshots_with_leak_period() {
+ public void persist_snapshots_with_new_code_period() {
OrganizationDto organizationDto = dbTester.organizations().insert();
ComponentDto viewDto = save(newView(organizationDto, "UUID_VIEW").setDbKey("KEY_VIEW"));
ComponentDto subViewDto = save(newSubView(viewDto, "UUID_SUBVIEW", "KEY_SUBVIEW"));
Component view = ViewsComponent.builder(VIEW, "KEY_VIEW").setUuid("UUID_VIEW").addChildren(subView).build();
treeRootHolder.setRoot(view);
- periodsHolder.setPeriod(new Period(LEAK_PERIOD_MODE_DATE, "2015-01-01", analysisDate));
+ periodsHolder.setPeriod(new Period("NUMBER_OF_DAYS", "30", analysisDate));
underTest.execute(new TestComputationStepContext());
SnapshotDto viewSnapshot = getUnprocessedSnapshot(viewDto.uuid());
- assertThat(viewSnapshot.getPeriodMode()).isEqualTo(LEAK_PERIOD_MODE_DATE);
+ assertThat(viewSnapshot.getPeriodMode()).isEqualTo("NUMBER_OF_DAYS");
assertThat(viewSnapshot.getPeriodDate()).isEqualTo(analysisDate);
assertThat(viewSnapshot.getPeriodModeParameter()).isNotNull();
}
+ 26 // level 1
+ 62 // content of DaoModule
+ 3 // content of EsModule
- + 52 // content of CorePropertyDefinitions
+ + 51 // content of CorePropertyDefinitions
+ 1 // StopFlagContainer
);
assertThat(
public void define(WebService.NewController context) {
WebService.NewAction action = context.createAction("set_baseline")
.setDescription("Set an analysis as the baseline of the New Code Period on a project or a long-lived branch.<br/>" +
- "This manually set baseline overrides the `sonar.leak.period` setting.<br/>" +
+ "This manually set baseline.<br/>" +
"Requires one of the following permissions:" +
"<ul>" +
" <li>'Administer System'</li>" +
public void define(WebService.NewController context) {
WebService.NewAction action = context.createAction("unset_baseline")
.setDescription("Unset any manually-set New Code Period baseline on a project or a long-lived branch.<br/>" +
- "Unsetting a manual baseline restores the use of the `sonar.leak.period` setting.<br/>" +
+ "Unsetting a manual baseline restores the use of the default new code period setting.<br/>" +
"Requires one of the following permissions:" +
"<ul>" +
" <li>'Administer System'</li>" +
import static java.util.Comparator.comparing;
import static java.util.Optional.ofNullable;
import static org.sonar.api.web.UserRole.USER;
-import static org.sonar.server.setting.ws.SettingsWs.SETTING_ON_BRANCHES;
-import static org.sonar.server.setting.ws.SettingsWsParameters.PARAM_BRANCH;
import static org.sonar.server.setting.ws.SettingsWsParameters.PARAM_COMPONENT;
-import static org.sonar.server.setting.ws.SettingsWsParameters.PARAM_PULL_REQUEST;
import static org.sonar.server.ws.KeyExamples.KEY_PROJECT_EXAMPLE_001;
import static org.sonar.server.ws.WsUtils.writeProtobuf;
private final SettingsWsSupport settingsWsSupport;
public ListDefinitionsAction(DbClient dbClient, ComponentFinder componentFinder, UserSession userSession, PropertyDefinitions propertyDefinitions,
- SettingsWsSupport settingsWsSupport) {
+ SettingsWsSupport settingsWsSupport) {
this.dbClient = dbClient;
this.componentFinder = componentFinder;
this.userSession = userSession;
action.createParam(PARAM_COMPONENT)
.setDescription("Component key")
.setExampleValue(KEY_PROJECT_EXAMPLE_001);
- settingsWsSupport.addBranchParam(action);
- settingsWsSupport.addPullRequestParam(action);
}
@Override
ListDefinitionsWsResponse.Builder wsResponse = ListDefinitionsWsResponse.newBuilder();
propertyDefinitions.getAll().stream()
.filter(definition -> qualifier.map(s -> definition.qualifiers().contains(s)).orElseGet(definition::global))
- .filter(definition -> wsRequest.getBranch() == null || SETTING_ON_BRANCHES.contains(definition.key()))
.filter(definition -> settingsWsSupport.isVisible(definition.key(), component))
.sorted(comparing(PropertyDefinition::category, String::compareToIgnoreCase)
.thenComparingInt(PropertyDefinition::index)
private static ListDefinitionsRequest toWsRequest(Request request) {
return new ListDefinitionsRequest()
- .setComponent(request.param(PARAM_COMPONENT))
- .setBranch(request.param(PARAM_BRANCH))
- .setPullRequest(request.param(PARAM_PULL_REQUEST));
+ .setComponent(request.param(PARAM_COMPONENT));
}
private static Optional<String> getQualifier(Optional<ComponentDto> component) {
- return component.isPresent() ? Optional.of(component.get().qualifier()) : Optional.empty();
+ return component.map(ComponentDto::qualifier);
}
private Optional<ComponentDto> loadComponent(ListDefinitionsRequest request) {
if (componentKey == null) {
return Optional.empty();
}
- ComponentDto component = componentFinder.getByKeyAndOptionalBranchOrPullRequest(dbSession, componentKey, request.getBranch(), request.getPullRequest());
+ ComponentDto component = componentFinder.getByKey(dbSession, componentKey);
userSession.checkComponentPermission(USER, component);
return Optional.of(component);
}
}
private static class ListDefinitionsRequest {
-
- private String branch;
private String component;
- private String pullRequest;
public ListDefinitionsRequest setComponent(@Nullable String component) {
this.component = component;
public String getComponent() {
return component;
}
-
- public ListDefinitionsRequest setBranch(@Nullable String branch) {
- this.branch = branch;
- return this;
- }
-
- @CheckForNull
- public String getBranch() {
- return branch;
- }
-
- public ListDefinitionsRequest setPullRequest(@Nullable String pullRequest) {
- this.pullRequest = pullRequest;
- return this;
- }
-
- @CheckForNull
- public String getPullRequest() {
- return pullRequest;
- }
}
+
}
import org.sonar.scanner.protocol.GsonHelper;
import org.sonar.server.component.ComponentFinder;
import org.sonar.server.exceptions.BadRequestException;
-import org.sonar.server.setting.ws.SettingValidations.SettingData;
import org.sonar.server.setting.SettingsChangeNotifier;
+import org.sonar.server.setting.ws.SettingValidations.SettingData;
import org.sonar.server.user.UserSession;
import static com.google.common.base.Preconditions.checkArgument;
-import static java.lang.String.format;
import static org.sonar.server.exceptions.BadRequestException.checkRequest;
-import static org.sonar.server.setting.ws.SettingsWsParameters.PARAM_BRANCH;
import static org.sonar.server.setting.ws.SettingsWsParameters.PARAM_COMPONENT;
import static org.sonar.server.setting.ws.SettingsWsParameters.PARAM_FIELD_VALUES;
import static org.sonar.server.setting.ws.SettingsWsParameters.PARAM_KEY;
-import static org.sonar.server.setting.ws.SettingsWsParameters.PARAM_PULL_REQUEST;
import static org.sonar.server.setting.ws.SettingsWsParameters.PARAM_VALUE;
import static org.sonar.server.setting.ws.SettingsWsParameters.PARAM_VALUES;
import static org.sonar.server.ws.KeyExamples.KEY_PROJECT_EXAMPLE_001;
public void define(WebService.NewController context) {
WebService.NewAction action = context.createAction("set")
.setDescription("Update a setting value.<br>" +
- "Either '%s' or '%s' must be provided.<br> " +
- "The settings defined in conf/sonar.properties are read-only and can't be changed.<br/>" +
- "Requires one of the following permissions: " +
- "<ul>" +
- "<li>'Administer System'</li>" +
- "<li>'Administer' rights on the specified component</li>" +
- "</ul>",
+ "Either '%s' or '%s' must be provided.<br> " +
+ "The settings defined in conf/sonar.properties are read-only and can't be changed.<br/>" +
+ "Requires one of the following permissions: " +
+ "<li>'Administer System'</li>" +
+ "<li>'Administer' rights on the specified component</li>" +
+ "</ul>",
PARAM_VALUE, PARAM_VALUES)
.setSince("6.1")
.setChangelog(
.setDescription("Component key")
.setDeprecatedKey("componentKey", "6.3")
.setExampleValue(KEY_PROJECT_EXAMPLE_001);
-
- settingsWsSupport.addBranchParam(action);
- settingsWsSupport.addPullRequestParam(action);
}
@Override
SettingData settingData = new SettingData(settingKey, valuesFromRequest(request), component.orElse(null));
ImmutableList.of(validations.scope(), validations.qualifier(), validations.valueType())
.forEach(validation -> validation.accept(settingData));
- component.map(ComponentDto::getBranch)
- .ifPresent(b -> checkArgument(SettingsWs.SETTING_ON_BRANCHES.contains(settingKey), format("Setting '%s' cannot be set on a branch", settingKey)));
}
private static void validatePropertySet(SetRequest request, @Nullable PropertyDefinition definition) {
.setValue(request.param(PARAM_VALUE))
.setValues(request.multiParam(PARAM_VALUES))
.setFieldValues(request.multiParam(PARAM_FIELD_VALUES))
- .setComponent(request.param(PARAM_COMPONENT))
- .setBranch(request.param(PARAM_BRANCH))
- .setPullRequest(request.param(PARAM_PULL_REQUEST));
+ .setComponent(request.param(PARAM_COMPONENT));
checkArgument(set.getValues() != null, "Setting values must not be null");
checkArgument(set.getFieldValues() != null, "Setting fields values must not be null");
return set;
*/
package org.sonar.server.setting.ws;
-import com.google.common.collect.ImmutableSet;
-import java.util.Set;
import org.sonar.api.server.ws.WebService;
-import static org.sonar.core.config.CorePropertyDefinitions.LEAK_PERIOD;
-
public class SettingsWs implements WebService {
- public static final Set<String> SETTING_ON_BRANCHES = ImmutableSet.of(LEAK_PERIOD);
-
private final SettingsWsAction[] actions;
public SettingsWs(SettingsWsAction... actions) {
import java.util.stream.Collector;
import java.util.stream.Collectors;
import org.sonar.api.server.ServerSide;
-import org.sonar.api.server.ws.WebService;
import org.sonar.api.web.UserRole;
import org.sonar.db.component.ComponentDto;
import org.sonar.db.permission.OrganizationPermission;
import static java.lang.String.format;
import static java.util.Arrays.stream;
import static org.sonar.api.web.UserRole.ADMIN;
-import static org.sonar.server.setting.ws.SettingsWsParameters.PARAM_BRANCH;
-import static org.sonar.server.setting.ws.SettingsWsParameters.PARAM_PULL_REQUEST;
-import static org.sonar.server.ws.KeyExamples.KEY_BRANCH_EXAMPLE_001;
-import static org.sonar.server.ws.KeyExamples.KEY_PULL_REQUEST_EXAMPLE_001;
@ServerSide
public class SettingsWsSupport {
.orElse(false);
}
- WebService.NewParam addBranchParam(WebService.NewAction action) {
- return action.createParam(PARAM_BRANCH)
- .setDescription("Branch key. Only available on following settings : %s", SettingsWs.SETTING_ON_BRANCHES.stream().collect(COMMA_JOINER))
- .setExampleValue(KEY_BRANCH_EXAMPLE_001)
- .setInternal(true)
- .setSince("6.6");
- }
-
- WebService.NewParam addPullRequestParam(WebService.NewAction action) {
- return action.createParam(PARAM_PULL_REQUEST)
- .setDescription("Pull request. Only available on following settings : %s", SettingsWs.SETTING_ON_BRANCHES.stream().collect(COMMA_JOINER))
- .setExampleValue(KEY_PULL_REQUEST_EXAMPLE_001)
- .setInternal(true)
- .setSince("7.1");
- }
}
import static org.sonar.api.web.UserRole.USER;
import static org.sonar.process.ProcessProperties.Property.SONARCLOUD_ENABLED;
import static org.sonar.server.setting.ws.PropertySetExtractor.extractPropertySetKeys;
-import static org.sonar.server.setting.ws.SettingsWsParameters.PARAM_BRANCH;
import static org.sonar.server.setting.ws.SettingsWsParameters.PARAM_COMPONENT;
import static org.sonar.server.setting.ws.SettingsWsParameters.PARAM_KEYS;
-import static org.sonar.server.setting.ws.SettingsWsParameters.PARAM_PULL_REQUEST;
import static org.sonar.server.setting.ws.SettingsWsSupport.isSecured;
import static org.sonar.server.user.AbstractUserSession.insufficientPrivilegesException;
import static org.sonar.server.ws.KeyExamples.KEY_PROJECT_EXAMPLE_001;
private final boolean isSonarCloud;
public ValuesAction(DbClient dbClient, ComponentFinder componentFinder, UserSession userSession, PropertyDefinitions propertyDefinitions,
- SettingsWsSupport settingsWsSupport, Configuration configuration) {
+ SettingsWsSupport settingsWsSupport, Configuration configuration) {
this.dbClient = dbClient;
this.componentFinder = componentFinder;
this.userSession = userSession;
action.createParam(PARAM_COMPONENT)
.setDescription("Component key")
.setExampleValue(KEY_PROJECT_EXAMPLE_001);
- settingsWsSupport.addBranchParam(action);
- settingsWsSupport.addPullRequestParam(action);
}
@Override
if (componentKey == null) {
return Optional.empty();
}
- ComponentDto component = componentFinder.getByKeyAndOptionalBranchOrPullRequest(dbSession, componentKey, valuesRequest.getBranch(), valuesRequest.getPullRequest());
+ ComponentDto component = componentFinder.getByKey(dbSession, componentKey);
if (!userSession.hasComponentPermission(USER, component) &&
!userSession.hasComponentPermission(UserRole.SCAN, component) &&
!userSession.hasPermission(OrganizationPermission.SCAN, component.getOrganizationUuid())) {
}
private static class ValuesRequest {
- private String branch;
- private String pullRequest;
private String component;
private List<String> keys;
- public ValuesRequest setBranch(@Nullable String branch) {
- this.branch = branch;
- return this;
- }
-
- @CheckForNull
- public String getBranch() {
- return branch;
- }
-
- public ValuesRequest setPullRequest(@Nullable String pullRequest) {
- this.pullRequest = pullRequest;
- return this;
- }
-
- @CheckForNull
- public String getPullRequest() {
- return pullRequest;
- }
-
public ValuesRequest setComponent(@Nullable String component) {
this.component = component;
return this;
private static ValuesRequest from(Request request) {
ValuesRequest result = new ValuesRequest()
- .setComponent(request.param(PARAM_COMPONENT))
- .setBranch(request.param(PARAM_BRANCH))
- .setPullRequest(request.param(PARAM_PULL_REQUEST));
+ .setComponent(request.param(PARAM_COMPONENT));
if (request.hasParam(PARAM_KEYS)) {
result.setKeys(request.paramAsStrings(PARAM_KEYS));
}
}
@Test
- public void show_with_leak_period_date() {
+ public void show_with_new_code_period_date() {
ComponentDto project = db.components().insertPrivateProject();
db.components().insertSnapshots(
newAnalysis(project).setPeriodDate(1_000_000_000L).setLast(false),
}
@Test
- public void return_measures_on_leak_period() {
+ public void return_measures_on_new_code_period() {
OrganizationDto organization = db.organizations().insert();
ComponentDto project = db.components().insertPrivateProject(organization);
userSession.addProjectPermission(UserRole.USER, project);
}
@Test
- public void fail_to_update_condition_on_rating_metric_on_leak_period() {
+ public void fail_to_update_condition_on_rating_metric_on_new_code_period() {
MetricDto metric = insertMetric(RATING, SQALE_RATING_KEY);
QualityGateDto qualityGate = db.qualityGates().insertQualityGate(db.getDefaultOrganization());
QualityGateConditionDto condition = db.qualityGates().addCondition(qualityGate, metric,
}
@Test
- public void create_condition_over_leak_period() {
+ public void create_condition_over_new_code_period() {
OrganizationDto organization = db.organizations().insert();
logInAsQualityGateAdmin(organization);
QGateWithOrgDto qualityGate = db.qualityGates().insertQualityGate(organization);
import org.sonarqube.ws.Settings.Definition;
import org.sonarqube.ws.Settings.ListDefinitionsWsResponse;
-import static java.lang.String.format;
import static java.util.Arrays.asList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.groups.Tuple.tuple;
assertThat(result.getDefinitionsList()).extracting(Definition::getKey).containsOnly("foo", "secret.secured");
}
- @Test
- public void definitions_on_branch() {
- ComponentDto project = db.components().insertMainBranch();
- userSession.logIn().addProjectPermission(USER, project);
- ComponentDto branch = db.components().insertProjectBranch(project);
- propertyDefinitions.addComponents(asList(
- PropertyDefinition.builder("sonar.leak.period").onQualifiers(PROJECT).build(),
- PropertyDefinition.builder("other").onQualifiers(PROJECT).build()));
-
- ListDefinitionsWsResponse result = ws.newRequest()
- .setParam("component", branch.getKey())
- .setParam("branch", branch.getBranch())
- .executeProtobuf(Settings.ListDefinitionsWsResponse.class);
-
- assertThat(result.getDefinitionsList()).extracting(Definition::getKey).containsExactlyInAnyOrder("sonar.leak.period");
- }
-
@Test
public void fail_when_user_has_not_project_browse_permission() {
userSession.logIn("project-admin").addProjectPermission(CODEVIEWER, project);
.execute();
}
- @Test
- public void fail_when_branch_not_found() {
- ComponentDto project = db.components().insertMainBranch();
- ComponentDto branch = db.components().insertProjectBranch(project);
- userSession.logIn().addProjectPermission(USER, project);
-
- expectedException.expect(NotFoundException.class);
- expectedException.expectMessage(format("Component '%s' on branch 'unknown' not found", branch.getKey()));
-
- ws.newRequest()
- .setParam("component", branch.getKey())
- .setParam("branch", "unknown")
- .execute();
- }
-
@Test
public void test_ws_definition() {
WebService.Action action = ws.getDef();
assertThat(action.isInternal()).isFalse();
assertThat(action.isPost()).isFalse();
assertThat(action.responseExampleAsString()).isNotEmpty();
- assertThat(action.params()).extracting(Param::key).containsExactlyInAnyOrder("component", "branch", "pullRequest");
+ assertThat(action.params()).extracting(Param::key).containsExactlyInAnyOrder("component");
}
@Test
assertThat(settingsChangeNotifier.wasCalled).isTrue();
}
- @Test
- public void set_leak_on_branch() {
- ComponentDto project = db.components().insertMainBranch();
- logInAsProjectAdministrator(project);
- ComponentDto branch = db.components().insertProjectBranch(project);
- String leakKey = "sonar.leak.period";
- definitions.addComponent(PropertyDefinition.builder(leakKey)
- .name("Leak")
- .description("desc")
- .onQualifiers(Qualifiers.PROJECT)
- .build());
- propertyDb.insertProperties(newComponentPropertyDto(leakKey, "1", branch));
-
- ws.newRequest()
- .setParam("key", leakKey)
- .setParam("value", "2")
- .setParam("component", branch.getKey())
- .setParam("branch", branch.getBranch())
- .execute();
-
- assertComponentSetting(leakKey, "2", branch.getId());
- }
-
@Test
public void fail_when_no_key() {
expectedException.expect(IllegalArgumentException.class);
.execute();
}
- @Test
- public void fail_when_branch_not_found() {
- ComponentDto project = db.components().insertMainBranch();
- logInAsProjectAdministrator(project);
- ComponentDto branch = db.components().insertProjectBranch(project);
- String settingKey = "not_allowed_on_branch";
-
- expectedException.expect(NotFoundException.class);
- expectedException.expectMessage(format("Component '%s' on branch 'unknown' not found", branch.getKey()));
-
- ws.newRequest()
- .setParam("key", settingKey)
- .setParam("value", "2")
- .setParam("component", branch.getKey())
- .setParam("branch", "unknown")
- .execute();
- }
-
- @Test
- public void fail_when_setting_not_allowed_setting_on_branch() {
- ComponentDto project = db.components().insertMainBranch();
- logInAsProjectAdministrator(project);
- ComponentDto branch = db.components().insertProjectBranch(project);
- String settingKey = "not_allowed_on_branch";
-
- expectedException.expect(IllegalArgumentException.class);
- expectedException.expectMessage(format("Setting '%s' cannot be set on a branch", settingKey));
-
- ws.newRequest()
- .setParam("key", settingKey)
- .setParam("value", "2")
- .setParam("component", branch.getKey())
- .setParam("branch", branch.getBranch())
- .execute();
- }
-
@Test
public void fail_when_setting_key_is_defined_in_sonar_properties() {
ComponentDto project = db.components().insertPrivateProject();
assertThat(definition.isInternal()).isFalse();
assertThat(definition.since()).isEqualTo("6.1");
assertThat(definition.params()).extracting(Param::key)
- .containsOnly("key", "value", "values", "fieldValues", "component", "branch", "pullRequest");
-
- Param branch = definition.param("branch");
- assertThat(branch.isInternal()).isTrue();
- assertThat(branch.since()).isEqualTo("6.6");
- assertThat(branch.description()).isEqualTo("Branch key. Only available on following settings : sonar.leak.period");
+ .containsOnly("key", "value", "values", "fieldValues", "component");
}
private void assertGlobalSetting(String key, String value) {
assertThat(result.getSettings(0).getValue()).isEqualTo("fi±∞…");
}
- @Test
- public void branch_values() {
- ComponentDto project = db.components().insertMainBranch();
- userSession.logIn().addProjectPermission(USER, project);
- ComponentDto branch = db.components().insertProjectBranch(project);
- definitions.addComponent(PropertyDefinition.builder("sonar.leak.period").onQualifiers(PROJECT).build());
- propertyDb.insertProperties(newComponentPropertyDto(branch).setKey("sonar.leak.period").setValue("two"));
-
- ValuesWsResponse result = newTester().newRequest()
- .setParam("keys", "sonar.leak.period")
- .setParam("component", branch.getKey())
- .setParam("branch", branch.getBranch())
- .executeProtobuf(ValuesWsResponse.class);
-
- assertThat(result.getSettingsList()).hasSize(1);
- assertSetting(result.getSettings(0), "sonar.leak.period", "two", false);
- }
-
- @Test
- public void branch_values_inherit_from_project() {
- ComponentDto project = db.components().insertMainBranch();
- userSession.logIn().addProjectPermission(USER, project);
- ComponentDto branch = db.components().insertProjectBranch(project);
- definitions.addComponent(PropertyDefinition.builder("sonar.leak.period").onQualifiers(PROJECT).build());
- propertyDb.insertProperties(newComponentPropertyDto(project).setKey("sonar.leak.period").setValue("two"));
-
- ValuesWsResponse result = newTester().newRequest()
- .setParam("keys", "sonar.leak.period")
- .setParam("component", branch.getKey())
- .setParam("branch", branch.getBranch())
- .executeProtobuf(ValuesWsResponse.class);
-
- assertThat(result.getSettingsList()).hasSize(1);
- assertSetting(result.getSettings(0), "sonar.leak.period", "two", true);
- }
-
@Test
public void fail_when_user_has_not_project_browse_permission() {
userSession.logIn("project-admin").addProjectPermission(CODEVIEWER, project);
.execute();
}
- @Test
- public void fail_when_branch_not_found() {
- ComponentDto project = db.components().insertMainBranch();
- ComponentDto branch = db.components().insertProjectBranch(project);
- String settingKey = "not_allowed_on_branch";
- userSession.logIn().addProjectPermission(USER, project);
-
- expectedException.expect(NotFoundException.class);
- expectedException.expectMessage(format("Component '%s' on branch 'unknown' not found", branch.getKey()));
-
- newTester().newRequest()
- .setParam("keys", settingKey)
- .setParam("component", branch.getKey())
- .setParam("branch", "unknown")
- .execute();
- }
-
@Test
public void test_example_json_response() {
logIn();
assertThat(action.isInternal()).isFalse();
assertThat(action.isPost()).isFalse();
assertThat(action.responseExampleAsString()).isNotEmpty();
- assertThat(action.params()).extracting(WebService.Param::key).containsExactlyInAnyOrder("keys", "component", "branch", "pullRequest");
+ assertThat(action.params()).extracting(WebService.Param::key).containsExactlyInAnyOrder("keys", "component");
}
@Test
public class CorePropertyDefinitions {
- public static final String LEAK_PERIOD = "sonar.leak.period";
- public static final String LEAK_PERIOD_MODE_DATE = "date";
- public static final String LEAK_PERIOD_MODE_VERSION = "version";
- public static final String LEAK_PERIOD_MODE_DAYS = "days";
- public static final String LEAK_PERIOD_MODE_PREVIOUS_VERSION = "previous_version";
- public static final String LEAK_PERIOD_MODE_MANUAL_BASELINE = "manual_baseline";
public static final String SONAR_ANALYSIS = "sonar.analysis.";
- private static final String DEFAULT_LEAK_PERIOD = LEAK_PERIOD_MODE_PREVIOUS_VERSION;
-
private static final String CATEGORY_ORGANIZATIONS = "organizations";
public static final String ORGANIZATIONS_ANYONE_CAN_CREATE = "sonar.organizations.anyoneCanCreate";
public static final String ORGANIZATIONS_CREATE_PERSONAL_ORG = "sonar.organizations.createPersonalOrg";
.type(PropertyType.USER_LOGIN)
.build(),
- // SCANNER
- PropertyDefinition.builder(LEAK_PERIOD)
- .name("New Code Period")
- .deprecatedKey("sonar.timemachine.period1")
- .description("Period used to compare measures and track new issues. Values are : " +
- "<ul class='bullet'><li>Number of days before analysis, for example 5.</li>" +
- "<li>A custom date. Format is yyyy-MM-dd, for example 2010-12-25</li>" +
- "<li>'previous_version' to compare to the previous version in the project history</li>" +
- "<li>A version, for example '1.2' or 'BASELINE'</li></ul>" +
- "<p>When specifying a number of days or a date, the snapshot selected for comparison is the first one available inside the corresponding time range. </p>" +
- "<p>This property has no effect when a baseline is manually set on a long-living branch, such as the main branch.<p/>" +
- "<p>Changing this property only takes effect after subsequent project inspections.<p/>")
- .defaultValue(DEFAULT_LEAK_PERIOD)
- .category(CoreProperties.CATEGORY_GENERAL)
- .subCategory(CoreProperties.SUBCATEGORY_DIFFERENTIAL_VIEWS)
- .onQualifiers(Qualifiers.PROJECT)
- .build(),
-
// CPD
PropertyDefinition.builder(CoreProperties.CPD_CROSS_PROJECT)
.defaultValue(Boolean.toString(false))
property.error.notRegexp=Not a valid Java regular expression
property.error.notInOptions=Not a valid option
property.category.scm=SCM
-property.sonar.leak.period.description=Period used to compare measures and track new issues. Values are:<ul class='bullet'><li>Number of days before analysis, for example 5.</li><li>A custom date. Format is yyyy-MM-dd, for example 2010-12-25</li><li>'previous_version' to compare to the previous version in the project history</li><li>A version, for example '1.2' or 'BASELINE'</li></ul><p>When specifying a number of days or a date, the snapshot selected as the baseline for comparison is the first one available inside the corresponding time range. Specifically, the first analysis in the range is considered to be before the New Code Period. </p><p>Changing this property only takes effect after subsequent project analyses.<p/>
-property.sonar.leak.period.description.intro=Period used to compare measures and track new issues. Values are:
-property.sonar.leak.period.description.item1=Number of days before analysis, for example 5.
-property.sonar.leak.period.description.item2=A custom date. Format is yyyy-MM-dd, for example 2010-12-25
-property.sonar.leak.period.description.item3='previous_version' to compare to the previous version in the project history
-property.sonar.leak.period.description.item4=A version, for example '1.2' or 'BASELINE'
-property.sonar.leak.period.description.details1=When specifying a number of days or a date, the snapshot selected as the baseline for comparison is the first one available inside the corresponding time range. Specifically, the first analysis in the range is considered to be before the New Code Period.
-property.sonar.leak.period.description.details2=Changing this property only takes effect after subsequent project analyses.
property.sonar.branch.longLivedBranches.regex.description=Regular expression used to detect whether a branch is a long living branch (as opposed to short living branch), based on its name. This applies only during first analysis, the type of a branch cannot be changed later.
@Test
public void all() {
List<PropertyDefinition> defs = CorePropertyDefinitions.all();
- assertThat(defs).hasSize(52);
+ assertThat(defs).hasSize(51);
}
@Test
projects / sonarqube.git / commitdiff