static List<PropertyDefinition> all() { return singletonList( PropertyDefinition.builder(CoreProperties.CORE_FORCE_AUTHENTICATION_PROPERTY) .defaultValue(Boolean.toString(CoreProperties.CORE_FORCE_AUTHENTICATION_DEFAULT_VALUE)) .name("Force user authentication") .description( "Forcing user authentication prevents anonymous users from accessing the SonarQube UI, or project data via the Web API. " + "Some specific read-only Web APIs, including those required to prompt authentication, are still available anonymously.") .type(PropertyType.BOOLEAN) .category(CoreProperties.CATEGORY_SECURITY) .build()); } }
@Test public void should_validate_boolean() { PropertyDefinition def = PropertyDefinition.builder("foo").name("foo").type(PropertyType.BOOLEAN).build(); assertThat(def.validate(null).isValid()).isTrue(); assertThat(def.validate("").isValid()).isTrue(); assertThat(def.validate(" ").isValid()).isTrue(); assertThat(def.validate("true").isValid()).isTrue(); assertThat(def.validate("false").isValid()).isTrue(); assertThat(def.validate("foo").isValid()).isFalse(); assertThat(def.validate("foo").getErrorKey()).isEqualTo("notBoolean"); }
@Test public void should_validate_integer() { PropertyDefinition def = PropertyDefinition.builder("foo").name("foo").type(PropertyType.INTEGER).build(); assertThat(def.validate(null).isValid()).isTrue(); assertThat(def.validate("").isValid()).isTrue(); assertThat(def.validate(" ").isValid()).isTrue(); assertThat(def.validate("123456").isValid()).isTrue(); assertThat(def.validate("foo").isValid()).isFalse(); assertThat(def.validate("foo").getErrorKey()).isEqualTo("notInteger"); }
@Test public void fail_when_multi_definition_and_single_value_provided() { definitions.addComponent(PropertyDefinition .builder("my.key") .name("foo") .description("desc") .category("cat") .type(PropertyType.STRING) .multiValues(true) .build()); expectedException.expect(BadRequestException.class); expectedException.expectMessage("Parameter 'value' must be used for single value setting. Parameter 'values' must be used for multi value setting."); callForGlobalSetting("my.key", "My Value"); }
@Test public void do_not_return_secured_and_license_settings_in_property_set_when_not_authenticated() { definitions.addComponent(PropertyDefinition .builder("foo") .type(PropertyType.PROPERTY_SET) .fields(asList( PropertyFieldDefinition.build("key").name("Key").build(), PropertyFieldDefinition.build("plugin.license.secured").name("License").type(LICENSE).build(), PropertyFieldDefinition.build("secret.secured").name("Secured").build())) .build()); propertyDb.insertPropertySet("foo", null, ImmutableMap.of("key", "key1", "plugin.license.secured", "ABCD", "secret.secured", "123456")); ValuesWsResponse result = executeRequestForGlobalProperties(); assertFieldValues(result.getSettings(0), ImmutableMap.of("key", "key1")); }
@Test public void return_property_set() { logIn(); definitions.addComponent(PropertyDefinition .builder("foo") .type(PropertyType.PROPERTY_SET) .fields(asList( PropertyFieldDefinition.build("key").name("Key").build(), PropertyFieldDefinition.build("size").name("Size").build())) .build()); propertyDb.insertPropertySet("foo", null, ImmutableMap.of("key", "key1", "size", "size1"), ImmutableMap.of("key", "key2")); executeAndVerify(null, null, "return_property_set.json"); }
@Test public void return_additional_settings_specific_for_scanner_when_no_keys() { logInAsAdmin(); definitions.addComponent(PropertyDefinition.builder("plugin.license.secured").type(LICENSE).build()); propertyDb.insertProperties( newGlobalPropertyDto().setKey("sonar.core.id").setValue("ID"), newGlobalPropertyDto().setKey("sonar.core.startTime").setValue("2017-01-01")); ValuesWsResponse result = executeRequestForGlobalProperties(); assertThat(result.getSettingsList()).extracting(Settings.Setting::getKey).containsOnly("sonar.core.id", "sonar.core.startTime"); }
@Test public void should_validate_single_select_list() { PropertyDefinition def = PropertyDefinition.builder("foo").name("foo").type(PropertyType.SINGLE_SELECT_LIST).options("de", "en").build(); assertThat(def.validate(null).isValid()).isTrue(); assertThat(def.validate("").isValid()).isTrue(); assertThat(def.validate(" ").isValid()).isTrue(); assertThat(def.validate("de").isValid()).isTrue(); assertThat(def.validate("en").isValid()).isTrue(); assertThat(def.validate("fr").isValid()).isFalse(); assertThat(def.validate("fr").getErrorKey()).isEqualTo("notInOptions"); }
@Test public void validate_regular_expression() { PropertyDefinition def = PropertyDefinition.builder("foo").name("foo").type(PropertyType.REGULAR_EXPRESSION).build(); assertThat(def.validate(null).isValid()).isTrue(); assertThat(def.validate("").isValid()).isTrue(); assertThat(def.validate(" ").isValid()).isTrue(); assertThat(def.validate("[a-zA-Z]").isValid()).isTrue(); assertThat(def.validate("[a-zA-Z").isValid()).isFalse(); assertThat(def.validate("[a-zA-Z").getErrorKey()).isEqualTo("notRegexp"); }
@Test public void should_validate_float() { PropertyDefinition def = PropertyDefinition.builder("foo").name("foo").type(PropertyType.FLOAT).build(); assertThat(def.validate(null).isValid()).isTrue(); assertThat(def.validate("").isValid()).isTrue(); assertThat(def.validate(" ").isValid()).isTrue(); assertThat(def.validate("123456").isValid()).isTrue(); assertThat(def.validate("3.14").isValid()).isTrue(); assertThat(def.validate("foo").isValid()).isFalse(); assertThat(def.validate("foo").getErrorKey()).isEqualTo("notFloat"); }
@Test public void does_not_returned_secured_and_license_settings_when_not_authenticated() { definitions.addComponents(asList( PropertyDefinition.builder("foo").build(), PropertyDefinition.builder("secret.secured").build(), PropertyDefinition.builder("plugin.license.secured").type(LICENSE).build())); propertyDb.insertProperties( newGlobalPropertyDto().setKey("foo").setValue("one"), newGlobalPropertyDto().setKey("secret.secured").setValue("password"), newGlobalPropertyDto().setKey("plugin.license.secured").setValue("ABCD")); executeAndVerify(null, null, "does_not_returned_secured_and_license_settings_when_not_authenticated.json"); }
@Test public void should_validate_string() { PropertyDefinition def = PropertyDefinition.builder("foo").name("foo").type(PropertyType.STRING).build(); assertThat(def.validate(null).isValid()).isTrue(); assertThat(def.validate("").isValid()).isTrue(); assertThat(def.validate(" ").isValid()).isTrue(); assertThat(def.validate("foo").isValid()).isTrue(); }
@Test public void return_license_settings_when_authenticated_but_not_admin() { logInAsProjectUser(); propertyDefinitions.addComponents(asList( PropertyDefinition.builder("foo").build(), PropertyDefinition.builder("secret.secured").build(), PropertyDefinition.builder("plugin.license.secured").type(PropertyType.LICENSE).build(), PropertyDefinition.builder("commercial.plugin").type(PropertyType.LICENSE).build())); ListDefinitionsWsResponse result = executeRequest(); assertThat(result.getDefinitionsList()).extracting(Definition::getKey).containsOnly("foo", "plugin.license.secured", "commercial.plugin"); }
@Test public void return_license_type() { logInAsAdmin(db.getDefaultOrganization()); propertyDefinitions.addComponents(asList( PropertyDefinition.builder("plugin.license.secured").type(PropertyType.LICENSE).build(), PropertyDefinition.builder("commercial.plugin").type(PropertyType.LICENSE).build())); ListDefinitionsWsResponse result = executeRequest(); assertThat(result.getDefinitionsList()).extracting(Definition::getKey, Definition::getType) .containsOnly(tuple("plugin.license.secured", LICENSE), tuple("commercial.plugin", LICENSE)); }
@Test public void return_license_type_in_property_set() { logIn(); propertyDefinitions.addComponent(PropertyDefinition .builder("foo") .type(PropertyType.PROPERTY_SET) .fields(PropertyFieldDefinition.build("license").name("License").type(PropertyType.LICENSE).build()) .build()); ListDefinitionsWsResponse result = executeRequest(); assertThat(result.getDefinitionsList()).hasSize(1); assertThat(result.getDefinitions(0).getFieldsList()).extracting(Settings.Field::getKey, Settings.Field::getType).containsOnly(tuple("license", LICENSE)); }
@Test public void return_secured_settings_when_not_authenticated_but_with_scan_permission() { userSession.anonymous().addPermission(SCAN, db.getDefaultOrganization()); propertyDefinitions.addComponents(asList( PropertyDefinition.builder("foo").build(), PropertyDefinition.builder("secret.secured").build(), PropertyDefinition.builder("plugin.license.secured").type(PropertyType.LICENSE).build(), PropertyDefinition.builder("commercial.plugin").type(PropertyType.LICENSE).build())); ListDefinitionsWsResponse result = executeRequest(); assertThat(result.getDefinitionsList()).extracting(Definition::getKey).containsOnly("foo", "secret.secured", "plugin.license.secured", "commercial.plugin"); }
@Test public void validate_long() { PropertyDefinition def = PropertyDefinition.builder("foo").name("foo").type(PropertyType.LONG).build(); assertThat(def.validate(null).isValid()).isTrue(); assertThat(def.validate("").isValid()).isTrue(); assertThat(def.validate(" ").isValid()).isTrue(); assertThat(def.validate("123456").isValid()).isTrue(); assertThat(def.validate("foo").isValid()).isFalse(); assertThat(def.validate("foo").getErrorKey()).isEqualTo("notInteger"); }
@Test public void return_secured_and_license_settings_when_project_admin() { logInAsProjectAdmin(); propertyDefinitions.addComponents(asList( PropertyDefinition.builder("foo").onQualifiers(PROJECT).build(), PropertyDefinition.builder("secret.secured").onQualifiers(PROJECT).build(), PropertyDefinition.builder("plugin.license.secured").onQualifiers(PROJECT).type(PropertyType.LICENSE).build())); ListDefinitionsWsResponse result = executeRequest(project.getDbKey()); assertThat(result.getDefinitionsList()).extracting(Definition::getKey).containsOnly("foo", "secret.secured", "plugin.license.secured"); }
@Test public void return_secured_and_license_settings_when_system_admin() { logInAsAdmin(db.getDefaultOrganization()); propertyDefinitions.addComponents(asList( PropertyDefinition.builder("foo").build(), PropertyDefinition.builder("secret.secured").build(), PropertyDefinition.builder("plugin.license.secured").type(PropertyType.LICENSE).build())); ListDefinitionsWsResponse result = executeRequest(); assertThat(result.getDefinitionsList()).extracting(Definition::getKey).containsOnly("foo", "secret.secured", "plugin.license.secured"); }
@Test public void does_not_returned_secured_and_license_settings_when_not_authenticated() { propertyDefinitions.addComponents(asList( PropertyDefinition.builder("foo").build(), PropertyDefinition.builder("secret.secured").build(), PropertyDefinition.builder("plugin.license.secured").type(PropertyType.LICENSE).build(), PropertyDefinition.builder("commercial.plugin").type(PropertyType.LICENSE).build())); ListDefinitionsWsResponse result = executeRequest(); assertThat(result.getDefinitionsList()).extracting(Definition::getKey).containsOnly("foo"); }