private Setting(PropertyDefinition definition) { this.key = definition.key(); this.value = definition.defaultValue(); this.componentId = null; this.definition = definition; this.propertySets = Collections.emptyList(); this.isDefault = true; }
private List<Setting> loadDefaultValues(Set<String> keys) { return propertyDefinitions.getAll().stream() .filter(definition -> keys.contains(definition.key())) .filter(defaultProperty -> !isEmpty(defaultProperty.defaultValue())) .map(Setting::createFromDefinition) .collect(Collectors.toList()); }
private PropertyDefinitions add(PropertyDefinition definition, String defaultCategory) { if (!definitions.containsKey(definition.key())) { definitions.put(definition.key(), definition); String category = StringUtils.defaultIfBlank(definition.category(), defaultCategory); categories.put(definition.key(), new Category(category)); String subcategory = StringUtils.defaultIfBlank(definition.subCategory(), category); subcategories.put(definition.key(), new SubCategory(subcategory)); if (!StringUtils.isEmpty(definition.deprecatedKey()) && !definition.deprecatedKey().equals(definition.key())) { deprecatedKeys.put(definition.deprecatedKey(), definition.key()); } } return this; }
private List<PropertyDto> loadDefaultSettings(Optional<String> key) { return propertyDefinitions.getAll().stream() .filter(definition -> !key.isPresent() || key.get().equals(definition.key())) .filter(defaultProperty -> !isEmpty(defaultProperty.defaultValue())) .map(definition -> new PropertyDto().setKey(definition.key()).setValue(definition.defaultValue())) .collect(Collectors.toList()); }
private List<String> getKeys(ResetRequest request) { return new ArrayList<>(request.getKeys().stream() .map(key -> { PropertyDefinition definition = definitions.get(key); return definition != null ? definition.key() : key; }) .collect(MoreCollectors.toSet())); }
private ListDefinitionsWsResponse doHandle(Request request) { ListDefinitionsRequest wsRequest = toWsRequest(request); Optional<ComponentDto> component = loadComponent(wsRequest); Optional<String> qualifier = getQualifier(component); 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(), definition, component)) .sorted(comparing(PropertyDefinition::category, String::compareToIgnoreCase) .thenComparingInt(PropertyDefinition::index) .thenComparing(PropertyDefinition::name, String::compareToIgnoreCase)) .forEach(definition -> addDefinition(definition, wsResponse)); return wsResponse.build(); }
private String persistedKey(SetRequest request) { PropertyDefinition definition = propertyDefinitions.get(request.getKey()); // handles deprecated key but persist the new key return definition == null ? request.getKey() : definition.key(); }
private void addDefinition(PropertyDefinition definition, ListDefinitionsWsResponse.Builder wsResponse) { String key = definition.key(); Settings.Definition.Builder builder = wsResponse.addDefinitionsBuilder() .setKey(key) .setType(Settings.Type.valueOf(definition.type().name())) .setMultiValues(definition.multiValues()); ofNullable(emptyToNull(definition.deprecatedKey())).ifPresent(builder::setDeprecatedKey); ofNullable(emptyToNull(definition.name())).ifPresent(builder::setName); ofNullable(emptyToNull(definition.description())).ifPresent(builder::setDescription); String category = propertyDefinitions.getCategory(key); ofNullable(emptyToNull(category)).ifPresent(builder::setCategory); String subCategory = propertyDefinitions.getSubCategory(key); ofNullable(emptyToNull(subCategory)).ifPresent(builder::setSubCategory); ofNullable(emptyToNull(definition.defaultValue())).ifPresent(builder::setDefaultValue); List<String> options = definition.options(); if (!options.isEmpty()) { builder.addAllOptions(options); } List<PropertyFieldDefinition> fields = definition.fields(); if (!fields.isEmpty()) { fields.forEach(fieldDefinition -> addField(fieldDefinition, builder)); } }
@Test public void all_includes_scanner_properties() { List<PropertyDefinition> defs = CorePropertyDefinitions.all(); assertThat(defs.stream() .filter(def -> def.key().equals(ScannerProperties.BRANCH_NAME)) .findFirst()).isPresent(); } }
public void start() { Loggers.get(RenameDeprecatedPropertyKeys.class).info("Rename deprecated property keys"); for (PropertyDefinition definition : definitions.getAll()) { if (!Strings.isNullOrEmpty(definition.deprecatedKey())) { dao.renamePropertyKey(definition.deprecatedKey(), definition.key()); } } } }
@Test public void should_create_hidden_property() { PropertyDefinition def = PropertyDefinition.builder("hello") .name("Hello") .hidden() .build(); assertThat(def.key()).isEqualTo("hello"); assertThat(def.qualifiers()).isEmpty(); assertThat(def.global()).isFalse(); }
@Test public void should_auto_detect_password_type() { PropertyDefinition def = PropertyDefinition.builder("scm.password.secured").name("SCM password").build(); assertThat(def.key()).isEqualTo("scm.password.secured"); assertThat(def.type()).isEqualTo(PropertyType.PASSWORD); }
@Test public void PropertyDef() { PropertyDefinition def = PropertyDefinition.builder("views.license.secured").name("Views license").build(); assertThat(def.key()).isEqualTo("views.license.secured"); assertThat(def.type()).isEqualTo(PropertyType.LICENSE); }
@Test public void should_create_from_annotation() { Properties props = AnnotationUtils.getAnnotation(Init.class, Properties.class); Property prop = props.value()[0]; PropertyDefinition def = PropertyDefinition.create(prop); assertThat(def.key()).isEqualTo("hello"); assertThat(def.name()).isEqualTo("Hello"); assertThat(def.defaultValue()).isEqualTo("world"); assertThat(def.category()).isEqualTo("categ"); assertThat(def.options()).containsOnly("de", "en"); assertThat(def.description()).isEqualTo("desc"); assertThat(def.type()).isEqualTo(PropertyType.FLOAT); assertThat(def.global()).isFalse(); assertThat(def.qualifiers()).containsOnly(Qualifiers.PROJECT, Qualifiers.MODULE); assertThat(def.multiValues()).isTrue(); assertThat(def.propertySetKey()).isEqualTo("set"); assertThat(def.fields()).isEmpty(); }
@Test public void should_create_property_with_default_values() { PropertyDefinition def = PropertyDefinition.builder("hello") .name("Hello") .build(); assertThat(def.key()).isEqualTo("hello"); assertThat(def.name()).isEqualTo("Hello"); assertThat(def.defaultValue()).isEmpty(); assertThat(def.category()).isEmpty(); assertThat(def.options()).isEmpty(); assertThat(def.description()).isEmpty(); assertThat(def.type()).isEqualTo(PropertyType.STRING); assertThat(def.global()).isTrue(); assertThat(def.qualifiers()).isEmpty(); assertThat(def.multiValues()).isFalse(); assertThat(def.propertySetKey()).isEmpty(); assertThat(def.fields()).isEmpty(); }
@Test public void should_create_from_annotation_default_values() { Properties props = AnnotationUtils.getAnnotation(DefaultValues.class, Properties.class); Property prop = props.value()[0]; PropertyDefinition def = PropertyDefinition.create(prop); assertThat(def.key()).isEqualTo("hello"); assertThat(def.name()).isEqualTo("Hello"); assertThat(def.defaultValue()).isEmpty(); assertThat(def.category()).isEmpty(); assertThat(def.options()).isEmpty(); assertThat(def.description()).isEmpty(); assertThat(def.type()).isEqualTo(PropertyType.STRING); assertThat(def.global()).isTrue(); assertThat(def.qualifiers()).isEmpty(); assertThat(def.multiValues()).isFalse(); assertThat(def.propertySetKey()).isEmpty(); assertThat(def.fields()).isEmpty(); }
private void assertPropertyDefinitions(ComponentContainer container, CoreExtension coreExtension, PropertyDefinition... definitions) { PropertyDefinitions propertyDefinitions = container.getComponentByType(PropertyDefinitions.class); if (definitions.length == 0) { assertThat(propertyDefinitions.getAll()).isEmpty(); } else { for (PropertyDefinition definition : definitions) { PropertyDefinition actual = propertyDefinitions.get(definition.key()); assertThat(actual.category()).isEqualTo(definition.category() == null ? coreExtension.getName() : definition.category()); } } }
@Test public void should_create_property() { PropertyDefinition def = PropertyDefinition.builder("hello") .name("Hello") .defaultValue("world") .category("categ") .options("de", "en") .description("desc") .type(PropertyType.FLOAT) .onlyOnQualifiers(Qualifiers.MODULE) .multiValues(true) .propertySetKey("set") .build(); assertThat(def.key()).isEqualTo("hello"); assertThat(def.name()).isEqualTo("Hello"); assertThat(def.defaultValue()).isEqualTo("world"); assertThat(def.category()).isEqualTo("categ"); assertThat(def.options()).containsOnly("de", "en"); assertThat(def.description()).isEqualTo("desc"); assertThat(def.type()).isEqualTo(PropertyType.FLOAT); assertThat(def.global()).isFalse(); assertThat(def.qualifiers()).containsOnly(Qualifiers.MODULE); assertThat(def.multiValues()).isTrue(); assertThat(def.propertySetKey()).isEqualTo("set"); assertThat(def.fields()).isEmpty(); }
@Test public void get_trims_key_before_looking_for_replacement() { Random random = new Random(); String key = RandomStringUtils.randomAlphanumeric(4); String deprecatedKey = RandomStringUtils.randomAlphanumeric(4); PropertyDefinitions underTest = new PropertyDefinitions(singletonList( PropertyDefinition.builder(key) .deprecatedKey(deprecatedKey) .build())); String untrimmedKey = blank(random) + deprecatedKey + blank(random); assertThat(underTest.get(untrimmedKey).key()) .describedAs("expecting key %s being returned for get(%s)", key, untrimmedKey) .isEqualTo(key); }
@Test public void sonarcloud_global_secured_properties_require_system_admin_permission() { PropertyDefinition securedDef = PropertyDefinition.builder("my.password.secured").build(); PropertyDefinition standardDef = PropertyDefinition.builder("my.property").build(); definitions.addComponents(asList(securedDef, standardDef)); propertyDb.insertProperties( newGlobalPropertyDto().setKey(securedDef.key()).setValue("securedValue"), newGlobalPropertyDto().setKey(standardDef.key()).setValue("standardValue")); // anonymous WsActionTester tester = newSonarCloudTester(); ValuesWsResponse response = executeRequest(tester, null, securedDef.key(), standardDef.key()); assertThat(response.getSettingsList()).extracting(Settings.Setting::getValue).containsExactly("standardValue"); // organization administrator but not system administrator userSession.logIn() .addPermission(OrganizationPermission.SCAN, db.getDefaultOrganization()); response = executeRequest(tester, null, securedDef.key(), standardDef.key()); assertThat(response.getSettingsList()).extracting(Settings.Setting::getValue).containsExactly("standardValue"); // organization administrator userSession.logIn() .addPermission(OrganizationPermission.ADMINISTER, db.getDefaultOrganization()); response = executeRequest(tester, null, securedDef.key(), standardDef.key()); assertThat(response.getSettingsList()).extracting(Settings.Setting::getValue).containsExactly("standardValue"); // system administrator userSession.logIn().setSystemAdministrator(); response = executeRequest(tester, null, securedDef.key(), standardDef.key()); assertThat(response.getSettingsList()).extracting(Settings.Setting::getValue).containsExactlyInAnyOrder("securedValue", "standardValue"); }