How to use

WebService$Controller

in

org.sonar.api.server.ws

 @Test
 public void define() {
  RestartAction action1 = new RestartAction(mock(UserSession.class), mock(ProcessCommandWrapper.class),
   mock(RestartFlagHolder.class), mock(WebServer.class));
  InfoAction action2 = new InfoAction(new AnonymousMockUserSession(), mock(SystemInfoWriter.class));
  SystemWs ws = new SystemWs(action1, action2);
  WebService.Context context = new WebService.Context();

  ws.define(context);

  assertThat(context.controllers()).hasSize(1);
  assertThat(context.controller("api/system").actions()).hasSize(2);
  assertThat(context.controller("api/system").action("info")).isNotNull();
 }
}

@Test
public void definition() {
 assertThat(underTest.path()).isEqualTo("api/project_tags");
 assertThat(underTest.since()).isEqualTo("6.4");
 assertThat(underTest.description()).isNotEmpty();
}

@Test
public void should_be_well_defined() {
 Controller controller = tester.controller(CONTROLLER_LANGUAGES);
 assertThat(controller).isNotNull();
 assertThat(controller.description()).isNotEmpty();
 assertThat(controller.isInternal()).isFalse();
 assertThat(controller.path()).isEqualTo(CONTROLLER_LANGUAGES);
 assertThat(controller.since()).isEqualTo("5.1");
 assertThat(controller.actions()).hasSize(1);
 Action list = controller.action(ACTION_LIST);
 assertThat(list).isNotNull();
 assertThat(list.description()).isNotEmpty();
 assertThat(list.handler()).isInstanceOf(ListAction.class);
 assertThat(list.isInternal()).isFalse();
 assertThat(list.isPost()).isFalse();
 assertThat(list.responseExampleAsString()).isNotEmpty();
 assertThat(list.params()).hasSize(2);
}

@Test
public void define_index_action() {
 WebService.Action action = controller.action("index");
 assertThat(action).isNotNull();
 assertThat(action.responseExampleAsString()).isNotEmpty();
}

 @Test
 public void create_update_properties() {
  WebService.Action action = ws.controller(ENDPOINT).action("update");
  assertThat(action.isPost()).isTrue();
 }
}

@Test
public void define_search_action() {
 WebService.Action action = controller.action("search");
 assertThat(action).isNotNull();
 assertThat(action.isPost()).isFalse();
 assertThat(action.responseExampleAsString()).isNotEmpty();
 assertThat(action.params()).hasSize(4);
}

@Test
public void delete_action_properties() {
 WebService.Action deleteAction = ws.controller(ENDPOINT).action("delete");
 assertThat(deleteAction.isPost()).isTrue();
}

@Test
public void define_update_action() {
 WebService.Action action = controller.action("update");
 assertThat(action).isNotNull();
 assertThat(action.isPost()).isTrue();
 assertThat(action.params()).hasSize(5);
}

@Test
public void define_list_action() {
 WebService.Controller controller = controller();
 WebService.Action listProfiles = controller.action("list");
 assertThat(listProfiles).isNotNull();
 assertThat(listProfiles.handler()).isInstanceOf(RemovedWebServiceHandler.class);
 assertThat(listProfiles.responseExampleAsString()).isNotEmpty();
 assertThat(listProfiles.params()).isEmpty();
}

@Test
public void definition() {
 assertThat(underTest.path()).isEqualTo("api/notifications");
}

@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 definition() {
  assertThat(underTest.path()).isEqualTo("api/favorites");
 }
}

private void defineParameterTestAction(Consumer<WebService.NewParam> newParam, String parameter) {
 String controllerPath = "my_controller";
 String actionPath = "my_action";
 WebService.Context context = new WebService.Context();
 WebService.NewController controller = context.createController(controllerPath);
 WebService.NewAction action = controller
  .createAction(actionPath)
  .setHandler(mock(RequestHandler.class));
 WebService.NewParam param = action.createParam(parameter);
 newParam.accept(param);
 controller.done();
 underTest.setAction(context.controller(controllerPath).action(actionPath));
}

@Test
public void ws_is_internal_if_all_actions_are_internal() {
 ((WebService) context -> {
  NewController newController = context.createController("api/rule");
  newDefaultAction(newController, "create").setInternal(true);
  newDefaultAction(newController, "update").setInternal(true);
  newController.done();
 }).define(context);
 assertThat(context.controller("api/rule").isInternal()).isTrue();
}

@Test
public void action_updatable_is_defined() {
 logInAsSystemAdministrator();
 WsTester wsTester = new WsTester();
 WebService.NewController newController = wsTester.context().createController(DUMMY_CONTROLLER_KEY);
 underTest.define(newController);
 newController.done();
 WebService.Controller controller = wsTester.controller(DUMMY_CONTROLLER_KEY);
 assertThat(controller.actions()).extracting("key").containsExactly("updates");
 WebService.Action action = controller.actions().iterator().next();
 assertThat(action.isPost()).isFalse();
 assertThat(action.description()).isNotEmpty();
 assertThat(action.responseExample()).isNotNull();
}

@Test
public void define_change_password_action() {
 WebService.Action action = controller.action("change_password");
 assertThat(action).isNotNull();
 assertThat(action.isPost()).isTrue();
 assertThat(action.params()).hasSize(3);
}

@Test
public void action_pending_is_defined() {
 logInAsSystemAdministrator();
 WsTester wsTester = new WsTester();
 WebService.NewController newController = wsTester.context().createController(DUMMY_CONTROLLER_KEY);
 underTest.define(newController);
 newController.done();
 WebService.Controller controller = wsTester.controller(DUMMY_CONTROLLER_KEY);
 assertThat(controller.actions()).extracting("key").containsExactly("pending");
 WebService.Action action = controller.actions().iterator().next();
 assertThat(action.isPost()).isFalse();
 assertThat(action.description()).isNotEmpty();
 assertThat(action.responseExample()).isNotNull();
}

@Test
public void define_template_users() {
 WebService.Action action = controller().action("template_users");
 assertThat(action).isNotNull();
 assertThat(action.isPost()).isFalse();
 assertThat(action.isInternal()).isTrue();
 assertThat(action.since()).isEqualTo("5.2");
 assertThat(action.param(PARAM_PERMISSION).isRequired()).isFalse();
}

@Test
public void action_updates_is_defined() {
 WsTester wsTester = new WsTester();
 WebService.NewController newController = wsTester.context().createController(DUMMY_CONTROLLER_KEY);
 underTest.define(newController);
 newController.done();
 WebService.Controller controller = wsTester.controller(DUMMY_CONTROLLER_KEY);
 assertThat(controller.actions()).extracting("key").containsExactly("upgrades");
 WebService.Action action = controller.actions().iterator().next();
 assertThat(action.isPost()).isFalse();
 assertThat(action.description()).isNotEmpty();
 assertThat(action.responseExample()).isNotNull();
 assertThat(action.params()).isEmpty();
}

 @Test
 public void define_create_action() {
  WebService.Action action = controller.action("create");
  assertThat(action).isNotNull();
  assertThat(action.isPost()).isTrue();
  assertThat(action.responseExampleAsString()).isNotEmpty();
  assertThat(action.params()).hasSize(3);
 }
}