assertThat(organizations.isRequired()).isFalse(); assertThat(organizations.defaultValue()).isNull(); assertThat(organizations.description()).isEqualTo("Comma-separated list of organization keys"); assertThat(organizations.exampleValue()).isEqualTo("my-org-1,foocorp"); assertThat(organizations.since()).isEqualTo("6.3"); assertThat(organizations.maxValuesAllowed()).isEqualTo(500); assertThat(page.isRequired()).isFalse(); assertThat(page.defaultValue()).isEqualTo("1"); assertThat(page.description()).isEqualTo("1-based page number"); assertThat(pageSize.isRequired()).isFalse(); assertThat(pageSize.defaultValue()).isEqualTo("100"); assertThat(pageSize.maximumValue()).isEqualTo(500); assertThat(pageSize.description()).isEqualTo("Page size. Must be greater than 0 and less or equal than 500"); assertThat(member.since()).isEqualTo("7.0"); assertThat(member.defaultValue()).isEqualTo(String.valueOf(false)); assertThat(member.isRequired()).isFalse();
private List<String> readMultiParamOrDefaultValue(String key, @Nullable WebService.Param definition) { checkArgument(definition != null, "BUG - parameter '%s' is undefined for action '%s'", key, action.key()); List<String> keyValues = readMultiParam(key); if (!keyValues.isEmpty()) { return keyValues; } String deprecatedKey = definition.deprecatedKey(); List<String> deprecatedKeyValues = deprecatedKey == null ? emptyList() : readMultiParam(deprecatedKey); if (!deprecatedKeyValues.isEmpty()) { return deprecatedKeyValues; } String defaultValue = definition.defaultValue(); return defaultValue == null ? emptyList() : singletonList(defaultValue); }
@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"); } }
@Override @CheckForNull public String param(String key) { WebService.Param definition = action.param(key); String rawValue = readParam(key, definition); String rawValueOrDefault = defaultString(rawValue, definition.defaultValue()); String value = rawValueOrDefault == null ? null : CharMatcher.WHITESPACE.trimFrom(rawValueOrDefault); validateRequiredValue(key, definition, rawValue); if (value == null) { return null; } validatePossibleValues(key, value, definition); validateMaximumLength(key, definition, rawValueOrDefault); validateMinimumLength(key, definition, rawValueOrDefault); validateMaximumValue(key, definition, value); return value; }
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(); }
@CheckForNull private String readParamOrDefaultValue(String key, @Nullable WebService.Param definition) { if (definition == null) { String message = String.format("BUG - parameter '%s' is undefined for action '%s'", key, action.key()); Loggers.get(getClass()).error(message); throw new IllegalArgumentException(message); } String deprecatedKey = definition.deprecatedKey(); String value = deprecatedKey != null ? StringUtils.defaultString(readParam(deprecatedKey), readParam(key)) : readParam(key); value = StringUtils.defaultString(value, definition.defaultValue()); if (value == null) { return null; } return value; }
private List<String> readMultiParamOrDefaultValue(String key, @Nullable WebService.Param definition) { checkArgument(definition != null, "BUG - parameter '%s' is undefined for action '%s'", key, action.key()); List<String> keyValues = readMultiParam(key); if (!keyValues.isEmpty()) { return keyValues; } String deprecatedKey = definition.deprecatedKey(); List<String> deprecatedKeyValues = deprecatedKey == null ? emptyList() : readMultiParam(deprecatedKey); if (!deprecatedKeyValues.isEmpty()) { return deprecatedKeyValues; } String defaultValue = definition.defaultValue(); return defaultValue == null ? emptyList() : singletonList(defaultValue); }
@CheckForNull @Override public List<String> paramAsStrings(String key) { WebService.Param definition = action.param(key); String value = defaultString(readParam(key, definition), definition.defaultValue()); if (value == null) { return null; } List<String> values = COMMA_SPLITTER.splitToList(value); return validateValues(values, definition); }
private static void validateMaximumLength(String key, WebService.Param definition, String valueOrDefault) { Integer maximumLength = definition.maximumLength(); if (maximumLength == null) { return; } int valueLength = valueOrDefault.length(); checkArgument(valueLength <= maximumLength, "'%s' length (%s) is longer than the maximum authorized (%s)", key, valueLength, maximumLength); }
private static void validateMaximumValue(String key, WebService.Param definition, String value) { Integer maximumValue = definition.maximumValue(); if (maximumValue == null) { return; } int valueAsInt = validateAsNumeric(key, value); checkArgument(valueAsInt <= maximumValue, "'%s' value (%s) must be less than %s", key, valueAsInt, maximumValue); }
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); }
private static void validateMinimumLength(String key, WebService.Param definition, String valueOrDefault) { Integer minimumLength = definition.minimumLength(); if (minimumLength == null) { return; } int valueLength = valueOrDefault.length(); checkArgument(valueLength >= minimumLength, "'%s' length (%s) is shorter than the minimum authorized (%s)", key, valueLength, minimumLength); }
private static List<String> validateValues(List<String> values, WebService.Param definition) { Integer maximumValues = definition.maxValuesAllowed(); checkArgument(maximumValues == null || values.size() <= maximumValues, "'%s' can contains only %s values, got %s", definition.key(), maximumValues, values.size()); values.forEach(value -> validatePossibleValues(definition.key(), value, definition)); return values; }
@CheckForNull private String readParam(String key, @Nullable WebService.Param definition) { checkArgument(definition != null, "BUG - parameter '%s' is undefined for action '%s'", key, action.key()); String deprecatedKey = definition.deprecatedKey(); return deprecatedKey != null ? defaultString(readParam(deprecatedKey), readParam(key)) : readParam(key); }
private void validate(String value, WebService.Param definition) { Set<String> possibleValues = definition.possibleValues(); if (possibleValues != null && !possibleValues.contains(value)) { throw new IllegalArgumentException(String.format( "Value of parameter '%s' (%s) must be one of: %s", definition.key(), value, possibleValues)); } } }
assertThat(organization.isRequired()).isFalse(); assertThat(organization.description()).isEqualTo("the organization to search projects in"); assertThat(organization.since()).isEqualTo("6.3"); assertThat(sort.defaultValue()).isEqualTo("name"); assertThat(sort.possibleValues()).containsExactlyInAnyOrder( "coverage", "reliability_rating", assertThat(asc.defaultValue()).isEqualTo("true"); assertThat(asc.possibleValues()).containsOnly("true", "false", "yes", "no"); assertThat(f.defaultValue()).isNull(); assertThat(f.possibleValues()).containsOnly("_all", "organizations", "analysisDate", "leakPeriodDate"); assertThat(facets.defaultValue()).isNull(); 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");
Assertions.assertThat(organization.description()).isEqualTo("The key of the organization"); Assertions.assertThat(organization.isInternal()).isTrue(); Assertions.assertThat(organization.isRequired()).isFalse(); Assertions.assertThat(organization.since()).isEqualTo("6.3"); assertThat(qParam.isRequired()).isFalse(); assertThat(qParam.description()).isEqualTo("Limit search to: " + "<ul>" + "<li>component names that contain the supplied string</li>" + 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(pParam.isRequired()).isFalse(); assertThat(pParam.defaultValue()).isEqualTo("1"); assertThat(pParam.description()).isEqualTo("1-based page number"); assertThat(psParam.isRequired()).isFalse(); assertThat(psParam.defaultValue()).isEqualTo("100"); assertThat(psParam.description()).isEqualTo("Page size. Must be greater than 0 and less or equal than 500"); assertThat(visibilityParam.isRequired()).isFalse(); assertThat(visibilityParam.description()).isEqualTo("Filter the projects that should be visible to everyone (public), or only specific user/groups (private).<br/>" + "If no visibility is specified, the default project visibility of the organization will be used."); assertThat(lastAnalysisBefore.isRequired()).isFalse(); assertThat(lastAnalysisBefore.since()).isEqualTo("6.6");
.matches(param -> "Foo Company".equals(param.exampleValue())) .matches(param -> param.minimumLength().equals(1)) .matches(param -> param.maximumLength().equals(255)) .matches(param -> param.description() != null); assertThat(action.param("key")) .matches(param -> !param.isRequired()) .matches(param -> "foo-company".equals(param.exampleValue())) .matches(param -> param.minimumLength().equals(1)) .matches(param -> param.maximumLength().equals(255)) .matches(param -> param.description() != null); assertThat(action.param("description")) .matches(param -> !param.isRequired()) .matches(param -> "The Foo company produces quality software for Bar.".equals(param.exampleValue())) .matches(param -> param.description() != null); assertThat(action.param("url")) .matches(param -> !param.isRequired()) .matches(param -> "https://www.foo.com".equals(param.exampleValue())) .matches(param -> param.description() != null); assertThat(action.param("avatar")) .matches(param -> !param.isRequired()) .matches(param -> "https://www.foo.com/foo.png".equals(param.exampleValue())) .matches(param -> param.description() != null); assertThat(action.param("installationId")) .matches(param -> !param.isRequired()) .matches(param -> param.isInternal());
assertThat(keyParam.key()).isEqualTo("key"); assertThat(keyParam.description()).isEqualTo("Key of the new rule"); assertThat(keyParam.isInternal()).isFalse(); assertThat(keyParam.toString()).isEqualTo("key"); assertThat(severityParam.key()).isEqualTo("severity"); assertThat(severityParam.description()).isNull(); assertThat(severityParam.deprecatedSince()).isEqualTo("5.3"); assertThat(severityParam.since()).isEqualTo("4.4"); assertThat(severityParam.deprecatedKey()).isEqualTo("old-severity"); assertThat(severityParam.deprecatedKeySince()).isEqualTo("4.5"); assertThat(severityParam.defaultValue()).isEqualTo("MAJOR"); assertThat(severityParam.possibleValues()).containsOnly("INFO", "MAJOR", "BLOCKER"); assertThat(severityParam.maxValuesAllowed()).isEqualTo(10); assertThat(internalParam.isInternal()).isTrue(); assertThat(action.param("p").defaultValue()).isEqualTo("1"); assertThat(action.param("p").description()).isNotEmpty(); 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(componentId.isRequired()).isFalse(); assertThat(componentId.description()).isNotNull(); assertThat(componentId.exampleValue()).isNotNull(); assertThat(componentId.deprecatedSince()).isEqualTo("6.4"); assertThat(componentId.deprecatedKey()).isEqualTo("id"); assertThat(componentId.deprecatedKeySince()).isEqualTo("6.4"); assertThat(component.isRequired()).isFalse(); assertThat(component.description()).isNotNull(); assertThat(component.exampleValue()).isNotNull(); assertThat(component.deprecatedKey()).isEqualTo("key"); assertThat(component.deprecatedKeySince()).isEqualTo("6.4"); assertThat(branch.isInternal()).isTrue(); assertThat(branch.isRequired()).isFalse(); assertThat(branch.since()).isEqualTo("6.6"); assertThat(pullRequest.isInternal()).isTrue(); assertThat(pullRequest.isRequired()).isFalse(); assertThat(pullRequest.since()).isEqualTo("7.1");