private static void validatePossibleValues(String key, String value, WebService.Param definition) { Set<String> possibleValues = definition.possibleValues(); if (possibleValues == null) { return; } checkArgument(possibleValues.contains(value), "Value of parameter '%s' (%s) must be one of: %s", key, value, possibleValues); }
@Test public void definition_with_exporters() { WebService.Action definition = newWsActionTester(newExporter("polop"), newExporter("palap")).getDef(); assertThat(definition.isPost()).isFalse(); assertThat(definition.isInternal()).isFalse(); assertThat(definition.params()).extracting("key").containsExactlyInAnyOrder("key", "language", "qualityProfile", "organization", "exporterKey"); WebService.Param exportersParam = definition.param("exporterKey"); assertThat(exportersParam.possibleValues()).containsOnly("polop", "palap"); assertThat(exportersParam.deprecatedKey()).isEqualTo("format"); assertThat(exportersParam.deprecatedKeySince()).isEqualTo("6.3"); assertThat(exportersParam.isInternal()).isFalse(); }
@Test public void test_definition() { WebService.Action action = ws.getDef(); assertThat(action.key()).isEqualTo("show"); assertThat(action.responseExampleAsString()).isNotEmpty(); assertThat(action.isPost()).isFalse(); assertThat(action.since()).isEqualTo("6.5"); WebService.Param profile = action.param("key"); assertThat(profile.isRequired()).isTrue(); assertThat(profile.isInternal()).isFalse(); assertThat(profile.description()).isNotEmpty(); WebService.Param compareToSonarWay = action.param("compareToSonarWay"); assertThat(compareToSonarWay.isRequired()).isFalse(); assertThat(compareToSonarWay.isInternal()).isTrue(); assertThat(compareToSonarWay.description()).isNotEmpty(); assertThat(compareToSonarWay.defaultValue()).isEqualTo("false"); assertThat(compareToSonarWay.possibleValues()).contains("true", "false"); }
assertThat(sort.possibleValues()).containsExactlyInAnyOrder( "coverage", "reliability_rating", assertThat(asc.possibleValues()).containsOnly("true", "false", "yes", "no"); assertThat(f.possibleValues()).containsOnly("_all", "organizations", "analysisDate", "leakPeriodDate"); assertThat(facets.possibleValues()).containsOnly("ncloc", "duplicated_lines_density", "coverage", "sqale_rating", "reliability_rating", "security_rating", "alert_status", "languages", "tags", "new_reliability_rating", "new_security_rating", "new_maintainability_rating", "new_coverage", "new_duplicated_lines_density", "new_lines");
assertThat(qualifierParam.isRequired()).isFalse(); assertThat(qualifierParam.description()).isEqualTo("Comma-separated list of component qualifiers. Filter the results with the specified qualifiers"); assertThat(qualifierParam.possibleValues()).containsOnly("TRK", "VW", "APP"); assertThat(qualifierParam.defaultValue()).isEqualTo("TRK"); assertThat(onProvisionedOnly.possibleValues()).containsExactlyInAnyOrder("true", "false", "yes", "no"); assertThat(onProvisionedOnly.defaultValue()).isEqualTo("false"); assertThat(onProvisionedOnly.since()).isEqualTo("6.6");
assertThat(severityParam.deprecatedKeySince()).isEqualTo("4.5"); assertThat(severityParam.defaultValue()).isEqualTo("MAJOR"); assertThat(severityParam.possibleValues()).containsOnly("INFO", "MAJOR", "BLOCKER"); assertThat(severityParam.maxValuesAllowed()).isEqualTo(10); assertThat(action.param("ps").defaultValue()).isEqualTo("20"); assertThat(action.param("ps").description()).isNotEmpty(); assertThat(action.param("f").possibleValues()).containsOnly("name", "severity"); assertThat(action.param("s").possibleValues()).containsOnly("name", "severity", "updatedAt"); assertThat(action.param("s").description()).isNotEmpty(); assertThat(action.param("asc").defaultValue()).isEqualTo("false");
assertThat(visibilityParam.isRequired()).isFalse(); assertThat(visibilityParam.since()).isEqualTo("6.4"); assertThat(visibilityParam.possibleValues()).containsExactlyInAnyOrder("private", "public");
assertThat(language.possibleValues()).containsExactly("xoo1", "xoo2"); assertThat(language.deprecatedSince()).isNull(); assertThat(language.description()).isEqualTo("Language key. If provided, only profiles for the given language are returned.");
@Test public void param_metadata_as_objects() { ((WebService) context -> { NewController newController = context.createController("api/rule"); NewAction create = newDefaultAction(newController, "create"); create.createParam("status") .setDefaultValue(RuleStatus.BETA) .setPossibleValues(RuleStatus.BETA, RuleStatus.READY) .setExampleValue(RuleStatus.BETA); create.createParam("max") .setDefaultValue(11) .setPossibleValues(11, 13, 17) .setExampleValue(17); newController.done(); }).define(context); WebService.Action action = context.controller("api/rule").action("create"); assertThat(action.param("status").defaultValue()).isEqualTo("BETA"); assertThat(action.param("status").possibleValues()).containsOnly("BETA", "READY"); assertThat(action.param("status").exampleValue()).isEqualTo("BETA"); assertThat(action.param("max").defaultValue()).isEqualTo("11"); assertThat(action.param("max").possibleValues()).containsOnly("11", "13", "17"); assertThat(action.param("max").exampleValue()).isEqualTo("17"); }
@Test public void definition() { WebService.Action definition = ws.getDef(); assertThat(definition.since()).isEqualTo("5.2"); assertThat(definition.isPost()).isTrue(); assertThat(definition.key()).isEqualTo("remove_project"); assertThat(definition.params()).extracting(WebService.Param::key).containsOnly("key", "qualityProfile", "project", "language", "projectUuid", "organization"); WebService.Param languageParam = definition.param("language"); assertThat(languageParam.possibleValues()).containsOnly(LANGUAGE_1, LANGUAGE_2); assertThat(languageParam.exampleValue()).isNull(); assertThat(languageParam.deprecatedSince()).isNullOrEmpty(); WebService.Param organizationParam = definition.param("organization"); assertThat(organizationParam.since()).isEqualTo("6.4"); assertThat(organizationParam.isInternal()).isTrue(); WebService.Param profile = definition.param("key"); assertThat(profile.deprecatedKey()).isEqualTo("profileKey"); WebService.Param profileName = definition.param("qualityProfile"); assertThat(profileName.deprecatedSince()).isNullOrEmpty(); WebService.Param project = definition.param("project"); assertThat(project.deprecatedKey()).isEqualTo("projectKey"); WebService.Param projectUuid = definition.param("projectUuid"); assertThat(projectUuid.deprecatedSince()).isEqualTo("6.5"); }
@Test public void definition() { WebService.Action definition = tester.getDef(); assertThat(definition.since()).isEqualTo("5.2"); assertThat(definition.isPost()).isTrue(); // parameters assertThat(definition.params()).extracting(WebService.Param::key) .containsExactlyInAnyOrder("key", "qualityProfile", "project", "language", "projectUuid", "organization"); WebService.Param profile = definition.param("key"); assertThat(profile.deprecatedKey()).isEqualTo("profileKey"); assertThat(profile.deprecatedSince()).isEqualTo("6.6"); WebService.Param languageParam = definition.param("language"); assertThat(languageParam.possibleValues()).containsOnly(LANGUAGE_1, LANGUAGE_2); assertThat(languageParam.exampleValue()).isNull(); WebService.Param project = definition.param("project"); assertThat(project.deprecatedKey()).isEqualTo("projectKey"); WebService.Param projectUuid = definition.param("projectUuid"); assertThat(projectUuid.deprecatedSince()).isEqualTo("6.5"); WebService.Param organizationParam = definition.param("organization"); assertThat(organizationParam.since()).isEqualTo("6.4"); assertThat(organizationParam.isInternal()).isTrue(); }
@Test public void verify_define() { WebService.Action action = wsTester.getDef(); assertThat(action.key()).isEqualTo(ACTION); assertThat(action.isPost()).isTrue(); assertThat(action.description()).isNotEmpty(); assertThat(action.isInternal()).isTrue(); assertThat(action.since()).isEqualTo("6.4"); assertThat(action.handler()).isEqualTo(underTest); assertThat(action.changelog()) .extracting(Change::getVersion, Change::getDescription) .contains(tuple("7.3", "This WS used to be located at /api/organizations/update_project_visibility")); WebService.Param projectVisibility = action.param(PARAM_PROJECT_VISIBILITY); assertThat(projectVisibility.isRequired()).isTrue(); assertThat(projectVisibility.possibleValues()).containsExactlyInAnyOrder("private", "public"); assertThat(projectVisibility.description()).isEqualTo("Default visibility for projects"); } }
@Test public void definition() { WebService.Action action = ws.getDef(); assertThat(action.key()).isEqualTo("search_members"); assertThat(action.params()).extracting(Param::key).containsOnly("q", "selected", "p", "ps", "organization"); assertThat(action.description()).isNotEmpty(); assertThat(action.responseExampleAsString()).isNotEmpty(); assertThat(action.since()).isEqualTo("6.4"); assertThat(action.isInternal()).isTrue(); assertThat(action.isPost()).isFalse(); assertThat(action.param("organization").isInternal()).isTrue(); Param selected = action.param("selected"); assertThat(selected.possibleValues()).containsOnly("selected", "deselected"); assertThat(selected.isInternal()).isTrue(); assertThat(selected.defaultValue()).isEqualTo("selected"); assertThat(action.param("ps").maximumValue()).isEqualTo(500); assertThat(action.param("q").minimumLength()).isEqualTo(2); }
@Test public void param_null_metadata() { ((WebService) context -> { NewController newController = context.createController("api/rule"); NewAction create = newDefaultAction(newController, "create"); create.createParam("status") .setDefaultValue(null) .setPossibleValues(Collections.emptyList()) .setExampleValue(null); create.createParam("max") .setPossibleValues((Object[]) null); newController.done(); }).define(context); WebService.Action action = context.controller("api/rule").action("create"); assertThat(action.param("status").defaultValue()).isNull(); assertThat(action.param("status").possibleValues()).isNull(); assertThat(action.param("status").exampleValue()).isNull(); assertThat(action.param("max").possibleValues()).isNull(); }
private static void writeParam(JsonWriter writer, WebService.Param param) { writer.beginObject(); writer.prop("key", param.key()); writer.prop("description", param.description()); writer.prop("since", param.since()); writer.prop("required", param.isRequired()); writer.prop("internal", param.isInternal()); writer.prop("defaultValue", param.defaultValue()); writer.prop("exampleValue", param.exampleValue()); writer.prop("deprecatedSince", param.deprecatedSince()); writer.prop("deprecatedKey", param.deprecatedKey()); writer.prop("deprecatedKeySince", param.deprecatedKeySince()); writer.prop("maxValuesAllowed", param.maxValuesAllowed()); ofNullable(param.possibleValues()).ifPresent(possibleValues -> writer.name("possibleValues").beginArray().values(possibleValues).endArray()); ofNullable(param.maximumLength()).ifPresent(maximumLength -> writer.prop("maximumLength", maximumLength)); ofNullable(param.minimumLength()).ifPresent(minimumLength -> writer.prop("minimumLength", minimumLength)); ofNullable(param.maximumValue()).ifPresent(maximumValue -> writer.prop("maximumValue", maximumValue)); writer.endObject(); }
@Test public void define_ws_parameters() { WsTester wsTester = new WsTester(); WebService.NewController controller = wsTester.context().createController("api/qualityprofiles"); WebService.NewAction newAction = controller.createAction("do").setHandler((request, response) -> { }); Languages languages = new Languages(newLanguage("java"), newLanguage("js")); QProfileReference.defineParams(newAction, languages); controller.done(); WebService.Action action = wsTester.controller("api/qualityprofiles").action("do"); assertThat(action.param("language")).isNotNull(); assertThat(action.param("language").possibleValues()).containsOnly("java", "js"); assertThat(action.param("key")).isNotNull(); assertThat(action.param("qualityProfile")).isNotNull(); }
@Test public void definition() { WebService.Action definition = ws.getDef(); assertThat(definition.key()).isEqualTo("set_setting"); assertThat(definition.isPost()).isTrue(); assertThat(definition.isInternal()).isTrue(); assertThat(definition.since()).isEqualTo("7.6"); assertThat(definition.params()) .extracting(WebService.Param::key, WebService.Param::isRequired, WebService.Param::maximumLength) .containsOnly( tuple("key", true, 100), tuple("value", true, 4000)); assertThat(definition.param("key").possibleValues()).containsExactlyInAnyOrder("notifications.optOut", "notifications.readDate"); }
@Test public void param_with_empty_possible_values() { ((WebService) context -> { NewController newController = context.createController("api/rule"); NewAction create = newDefaultAction(newController, "create"); create.createParam("status") .setPossibleValues(Collections.emptyList()); newController.done(); }).define(context); WebService.Action action = context.controller("api/rule").action("create"); // no possible values -> return null but not empty assertThat(action.param("status").possibleValues()).isNull(); }
@Test public void verify_definition() { WebService.Action action = ws.getDef(); assertThat(action.since()).isEqualTo("5.2"); assertThat(action.isPost()).isFalse(); assertThat(action.isInternal()).isFalse(); assertThat(action.responseExampleAsString()).isNotEmpty(); assertThat(action.params()).extracting(WebService.Param::key).containsOnly("p", "q", "ps", "f", "organization"); assertThat(action.param("f").possibleValues()).containsOnly("name", "description", "membersCount"); }
@Test public void values_of_process_parameter_are_names_of_processes() { Set<String> values = actionTester.getDef().param("process").possibleValues(); // values are lower-case and alphabetically ordered assertThat(values).containsExactly("app", "ce", "es", "web"); }