org.sonar.api.server.ws.WebService$Action.changelog java code examples

Common ways to obtain WebService$Action

private void myMethod () {
 WebService$Action w =WebService.Controller webServiceController;String actionKey;webServiceController.action(actionKey)
Smart code suggestions by Tabnine
}

private static void writeChangelog(JsonWriter writer, WebService.Action action) {
 writer.name("changelog").beginArray();
 action.changelog().stream()
  .sorted(Comparator.comparing(Change::getVersion).reversed())
  .forEach(changelog -> {
   writer.beginObject();
   writer.prop("description", changelog.getDescription());
   writer.prop("version", changelog.getVersion());
   writer.endObject();
  });
 writer.endArray();
}

@Test
public void test_definition() {
 WebService.Action definition = ws.getDef();
 assertThat(definition.key()).isEqualTo("current");
 assertThat(definition.description()).isEqualTo("Get the details of the current authenticated user.");
 assertThat(definition.since()).isEqualTo("5.2");
 assertThat(definition.isPost()).isFalse();
 assertThat(definition.isInternal()).isTrue();
 assertThat(definition.responseExampleAsString()).isNotEmpty();
 assertThat(definition.params()).isEmpty();
 assertThat(definition.changelog()).hasSize(2);
}

@Test
public void test_definition() {
 WebService.Action def = ws.getDef();
 assertThat(def.isPost()).isTrue();
 assertThat(def.isInternal()).isTrue();
 assertThat(def.since()).isEqualTo("6.5");
 assertThat(def.params()).isEmpty();
 assertThat(def.changelog()).isEmpty();
}

@Test
public void definition() {
 WebService.Action def = ws.getDef();
 assertThat(def.description()).isNotEmpty();
 assertThat(def.isPost()).isTrue();
 assertThat(def.since()).isEqualTo("4.3");
 assertThat(def.changelog()).extracting(Change::getVersion, Change::getDescription).containsExactly(
  tuple("6.6", "The parameter 'gateId' was removed"));
 assertThat(def.params())
  .extracting(WebService.Param::key, WebService.Param::isRequired)
  .containsExactlyInAnyOrder(
   tuple("projectKey", false),
   tuple("projectId", false),
   tuple("organization", false));
}

@Test
public void definition() {
 WebService.Action action = ws.getDef();
 assertThat(action.description()).isNotEmpty();
 assertThat(action.isInternal()).isFalse();
 assertThat(action.since()).isEqualTo("6.1");
 assertThat(action.changelog()).extracting(Change::getVersion, Change::getDescription).containsExactlyInAnyOrder(
  tuple("6.6", "The parameter 'projectId' has been removed"),
  tuple("6.6", "The parameter 'projectKey' has been renamed to 'project'"),
  tuple("6.6", "This webservice is now part of the public API"));
 assertThat(action.params())
  .extracting(WebService.Param::key, WebService.Param::isRequired)
  .containsExactlyInAnyOrder(
   tuple("project", true),
   tuple("organization", false));
}

@Test
public void verify_definition() {
 WebService.Action action = ws.getDef();
 assertThat(action.since()).isEqualTo("4.3");
 assertThat(action.key()).isEqualTo("list");
 assertThat(action.isPost()).isFalse();
 assertThat(action.isInternal()).isFalse();
 assertThat(action.changelog()).extracting(Change::getVersion, Change::getDescription)
  .containsExactlyInAnyOrder(
   tuple("7.0", "'isDefault' field is added on quality gate"),
   tuple("7.0", "'default' field on root level is deprecated"),
   tuple("7.0", "'isBuiltIn' field is added in the response"),
   tuple("7.0", "'actions' fields are added in the response"));
 assertThat(action.params()).extracting(WebService.Param::key, WebService.Param::isRequired)
  .containsExactlyInAnyOrder(tuple("organization", false));
}

 @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 verify_definition() {
 WebService.Action def = ws.getDef();
 assertThat(def.isInternal()).isTrue();
 assertThat(def.description()).isEqualTo("Get information concerning organization navigation for the current user");
 assertThat(def.since()).isEqualTo("6.3");
 assertThat(def.changelog()).extracting(Change::getVersion, Change::getDescription).containsExactlyInAnyOrder(
  tuple("6.4", "The field 'projectVisibility' is added"));
 assertThat(def.params()).hasSize(1);
 WebService.Param organization = def.param("organization");
 assertThat(organization.description()).isEqualTo("the organization key");
 assertThat(organization.isRequired()).isTrue();
 assertThat(organization.exampleValue()).isEqualTo("my-org");
}

@Test
public void definition() {
 init();
 WebService.Action action = ws.getDef();
 assertThat(action.since()).isEqualTo("5.2");
 assertThat(action.isPost()).isFalse();
 assertThat(action.isInternal()).isTrue();
 assertThat(action.description()).isNotNull();
 assertThat(action.responseExample()).isNotNull();
 assertThat(action.changelog()).extracting(Change::getVersion, Change::getDescription).containsExactlyInAnyOrder(
  tuple("6.4", "The 'visibility' field is added"),
  tuple("7.3", "The 'almRepoUrl' and 'almId' fields are added"),
  tuple("7.6", "The use of module keys in parameter 'component' is deprecated"));
 WebService.Param componentId = action.param(PARAM_COMPONENT);
 assertThat(componentId.isRequired()).isFalse();
 assertThat(componentId.description()).isNotNull();
 assertThat(componentId.exampleValue()).isNotNull();
 assertThat(componentId.deprecatedKey()).isEqualTo("componentKey");
 assertThat(componentId.deprecatedKeySince()).isEqualTo("6.4");
}

@Test
public void verify_definition() {
 WebService.Action action = ws.getDef();
 assertThat(action.since()).isEqualTo("6.3");
 assertThat(action.isPost()).isFalse();
 assertThat(action.isInternal()).isFalse();
 assertThat(action.changelog()).extracting(Change::getVersion, Change::getDescription).containsExactlyInAnyOrder(
  tuple("7.6", "The use of 'BRC' as value for parameter 'qualifiers' is deprecated"));
 assertThat(action.responseExampleAsString()).isNotEmpty();
 assertThat(action.params()).hasSize(6);
 WebService.Param pageSize = action.param("ps");
 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");
 WebService.Param qualifiers = action.param("qualifiers");
 assertThat(qualifiers.isRequired()).isTrue();
 WebService.Param organization = action.param("organization");
 assertThat(organization.isRequired()).isFalse();
 assertThat(organization.description()).isEqualTo("Organization key");
 assertThat(organization.isInternal()).isTrue();
 assertThat(organization.exampleValue()).isEqualTo("my-org");
 assertThat(organization.since()).isEqualTo("6.3");
}

@Test
public void define_suggestions_action() {
 WebService.Action action = ws.getDef();
 assertThat(action).isNotNull();
 assertThat(action.isInternal()).isTrue();
 assertThat(action.isPost()).isFalse();
 assertThat(action.handler()).isNotNull();
 assertThat(action.responseExampleAsString()).isNotEmpty();
 assertThat(action.params()).extracting(WebService.Param::key).containsExactlyInAnyOrder(
  PARAM_MORE,
  PARAM_QUERY,
  PARAM_RECENTLY_BROWSED);
 assertThat(action.changelog()).extracting(Change::getVersion, Change::getDescription).containsExactlyInAnyOrder(
  tuple("7.6", "The use of 'BRC' as value for parameter 'more' is deprecated"),
  tuple("6.4", "Parameter 's' is optional"));
 WebService.Param recentlyBrowsed = action.param(PARAM_RECENTLY_BROWSED);
 assertThat(recentlyBrowsed.since()).isEqualTo("6.4");
 assertThat(recentlyBrowsed.exampleValue()).isNotEmpty();
 assertThat(recentlyBrowsed.description()).isNotEmpty();
 assertThat(recentlyBrowsed.isRequired()).isFalse();
 WebService.Param query = action.param(PARAM_QUERY);
 assertThat(query.exampleValue()).isNotEmpty();
 assertThat(query.description()).isNotEmpty();
 assertThat(query.isRequired()).isFalse();
}

@Test
public void verify_definition() {
 WebService.Action action = ws.getDef();
 assertThat(action.since()).isEqualTo("5.4");
 assertThat(action.description()).isNotNull();
 assertThat(action.responseExample()).isNotNull();
 assertThat(action.changelog()).extracting(Change::getVersion, Change::getDescription).containsExactlyInAnyOrder(
  tuple("7.6", "The use of 'BRC' as value for parameter 'qualifiers' is deprecated"),
  tuple("7.6", "The use of module keys in parameter 'component' is deprecated"),
  tuple("6.4", "The field 'id' is deprecated in the response"));
 assertThat(action.params()).extracting(Param::key).containsExactlyInAnyOrder("component", "componentId", "branch", "pullRequest", "qualifiers", "strategy",
  "q", "s", "p", "asc", "ps");
 Param componentId = action.param(PARAM_COMPONENT_ID);
 assertThat(componentId.isRequired()).isFalse();
 assertThat(componentId.description()).isNotNull();
 assertThat(componentId.exampleValue()).isNotNull();
 assertThat(componentId.deprecatedSince()).isEqualTo("6.4");
 assertThat(componentId.deprecatedKey()).isEqualTo("baseComponentId");
 assertThat(componentId.deprecatedKeySince()).isEqualTo("6.4");
 Param component = action.param(PARAM_COMPONENT);
 assertThat(component.isRequired()).isFalse();
 assertThat(component.description()).isNotNull();
 assertThat(component.exampleValue()).isNotNull();
 assertThat(component.deprecatedKey()).isEqualTo("baseComponentKey");
 assertThat(component.deprecatedKeySince()).isEqualTo("6.4");
 Param branch = action.param(PARAM_BRANCH);
 assertThat(branch.isInternal()).isTrue();
 assertThat(branch.isRequired()).isFalse();
 assertThat(branch.since()).isEqualTo("6.6");
}

assertThat(definition.isPost()).isFalse();
assertThat(definition.changelog())
 .extracting(Change::getVersion, Change::getDescription)
 .containsExactlyInAnyOrder(

assertThat(action.description()).isNotNull();
assertThat(action.responseExample()).isNotNull();
assertThat(action.changelog()).extracting(Change::getVersion, Change::getDescription).containsExactlyInAnyOrder(
 tuple("6.4", "Analysis date has been added to the response"),
 tuple("6.4", "The field 'id' is deprecated in the response"),

@Test
public void verify_definition() {
 WebService.Action action = ws.getDef();
 assertThat(action.key()).isEqualTo("rename");
 assertThat(action.since()).isEqualTo("4.3");
 assertThat(action.changelog()).isEmpty();
 assertThat(action.params())
  .extracting(WebService.Param::key, WebService.Param::isRequired)
  .containsExactlyInAnyOrder(
   tuple("id", true),
   tuple("name", true),
   tuple("organization", false));
}

assertThat(showAction.responseExampleAsString()).isNotEmpty();
assertThat(showAction.deprecatedSince()).isNull();
assertThat(showAction.changelog()).isEmpty();
assertThat(createAction.isPost()).isTrue();
assertThat(createAction.isInternal()).isTrue();
assertThat(createAction.changelog()).extracting(Change::getVersion, Change::getDescription).containsOnly(
 tuple("6.4", "Last event"), tuple("6.0", "Old event"), tuple("4.5.6", "Very old event"));

assertThat(def.responseExampleAsString()).isNotEmpty();
assertThat(def.params().stream().map(Param::key).collect(toList())).containsOnly("organization", "filter", "facets", "s", "asc", "ps", "p", "f");
assertThat(def.changelog()).extracting(Change::getVersion, Change::getDescription).containsExactlyInAnyOrder(
 tuple("6.4", "The 'languages' parameter accepts 'filter' to filter by language"),
 tuple("6.4", "The 'visibility' field is added"),

@Test
public void api_definition() {
 WebService.Action definition = ws.getDef();
 assertThat(definition.since()).isEqualTo("6.1");
 assertThat(definition.isPost()).isTrue();
 assertThat(definition.key()).isEqualTo("update_key");
 assertThat(definition.changelog()).hasSize(2);
 assertThat(definition.params())
  .hasSize(3)
  .extracting(Param::key)
  .containsOnlyOnce("projectId", "from", "to");
}

private static void writeChangelog(JsonWriter writer, WebService.Action action) {
 writer.name("changelog").beginArray();
 action.changelog().stream()
  .sorted(Comparator.comparing(Change::getVersion).reversed())
  .forEach(changelog -> {
   writer.beginObject();
   writer.prop("description", changelog.getDescription());
   writer.prop("version", changelog.getVersion());
   writer.endObject();
  });
 writer.endArray();
}

@Test
public void definition() {
 WebService.Action action = ws.getDef();
 assertThat(action.description()).isEqualTo("Get the list of provisioned projects.<br> " +
  "Web service is deprecated. Use api/projects/search instead, with onProvisionedOnly=true.<br> " +
  "Require 'Create Projects' permission.");
 assertThat(action.since()).isEqualTo("5.2");
 assertThat(action.changelog()).extracting(Change::getVersion, Change::getDescription).containsExactlyInAnyOrder(
  tuple("6.4", "The 'uuid' field is deprecated in the response"),
  tuple("6.4", "Paging response fields is now in a Paging object"));
 assertThat(action.deprecatedSince()).isEqualTo("6.6");
 assertThat(action.params()).hasSize(5);
 Param organization = action.param(PARAM_ORGANIZATION);
 assertThat(organization.description()).isEqualTo("The key of the organization");
 assertThat(organization.isInternal()).isTrue();
 assertThat(organization.isRequired()).isFalse();
 assertThat(organization.since()).isEqualTo("6.3");
}

Popular methods of WebService$Action

Popular in Java

Start an intent from android
runOnUiThread (Activity)
setRequestProperty (URLConnection)
getExternalFilesDir (Context)
Pointer (com.sun.jna)
An abstraction for a native pointer data type. A Pointer instance represents, on the Java side, a na
Thread (java.lang)
A thread is a thread of execution in a program. The Java Virtual Machine allows an application to ha
SortedSet (java.util)
SortedSet is a Set which iterates over its elements in a sorted order. The order is determined eithe
ServletException (javax.servlet)
Defines a general exception a servlet can throw when it encounters difficulty.
Options (org.apache.commons.cli)
Main entry-point into the library. Options represents a collection of Option objects, which describ
Runner (org.openjdk.jmh.runner)
Top 17 Free Sublime Text Plugins

How to use changelogmethodin org.sonar.api.server.ws.WebService$Action

Best Java code snippets using org.sonar.api.server.ws.WebService$Action.changelog (Showing top 20 results out of 315)

How to use
changelog
method
in
org.sonar.api.server.ws.WebService$Action