throw new UnsupportedOperationException("This web service is implemented in rails");
}
+ public static WebService.NewParam addFormatParam(WebService.NewAction action) {
+ return action.createParam("format")
+ .setDescription("Response format can be set through:" +
+ "<ul>" +
+ "<li>Parameter format: xml | json</li>" +
+ "<li>Or the 'Accept' property in the HTTP header:" +
+ "<ul>" +
+ "<li>Accept:text/xml</li>" +
+ "<li>Accept:application/json</li>" +
+ "</ul></li></ul>" +
+ "If nothing is set, json is used")
+ .setPossibleValues("json", "xml");
+ }
+
+ public static WebService.NewParam addJsonOnlyFormatParam(WebService.NewAction action) {
+ return action.createParam("format")
+ .setDescription("Only json response format is available")
+ .setPossibleValues("json");
+ }
+
}
NewController controller = context.createController("api/authentication");
controller.setDescription("Check authentication credentials");
- controller.createAction("validate")
+ defineValidateAction(controller);
+
+ controller.done();
+ }
+
+ private void defineValidateAction(NewController controller) {
+ NewAction action = controller.createAction("validate")
.setDescription("Check credentials")
.setSince("3.3")
.setHandler(RailsHandler.INSTANCE)
.setResponseExample(Resources.getResource(this.getClass(), "example-validate.json"));
- controller.done();
+ RailsHandler.addFormatParam(action);
}
}
.setRequired(true)
.setDescription("Substring of project key (minimum 2 characters)")
.setExampleValue("sonar");
+
+ RailsHandler.addJsonOnlyFormatParam(action);
}
}
.setDescription("Load version")
.setDefaultValue("false")
.setPossibleValues("true", "false", "last");
+
+ RailsHandler.addFormatParam(action);
}
private void defineCreateAction(NewController controller) {
.setDescription("Provision a project. Requires Provision Projects permission")
.setSince("4.0")
.setPost(true)
- .setHandler(RailsHandler.INSTANCE);
+ .setHandler(RailsHandler.INSTANCE)
+ .setResponseExample(Resources.getResource(this.getClass(), "projects-example-create.json"));
action.createParam("key")
.setDescription("Key of the project")
.setDescription("Name of the project")
.setRequired(true)
.setExampleValue("SonarQube");
+
+ RailsHandler.addFormatParam(action);
}
private void defineDestroyAction(NewController controller) {
.setDescription("Former components web service")
.setSince("2.10");
- defineSystemAction(controller);
+ defineIndexAction(controller);
defineSearchAction(controller);
controller.done();
}
- private void defineSystemAction(NewController controller) {
+ private void defineIndexAction(NewController controller) {
NewAction action = controller.createAction("index")
.setDescription("Get a list of components. Requires Browse permission on resource")
.setSince("2.10")
"(such as 'blocker_violations', 'critical_violations', ..., 'new_blocker_violations', ...). Possible values: true | false | list of rule ids")
.setDefaultValue("false")
.setExampleValue("true");
+
+ RailsHandler.addFormatParam(action);
}
private void defineSearchAction(NewController controller) {
.setDescription("Page size")
.setDefaultValue("10")
.setExampleValue("15");
+
+ RailsHandler.addJsonOnlyFormatParam(action);
}
}
NewController controller = context.createController("api/action_plans");
controller.setDescription("Action plans management");
- WebService.NewAction search = controller.createAction("search")
+ defineSearchAction(controller);
+ defineCreateAction(controller);
+ defineUpdateAction(controller);
+ defineDeleteAction(controller);
+ defineOpenAction(controller);
+ defineCloseAction(controller);
+
+ controller.done();
+ }
+
+ private void defineSearchAction(NewController controller) {
+ WebService.NewAction action = controller.createAction("search")
.setDescription("Get a list of action plans. Requires Browse permission on project")
.setSince("3.6")
.setHandler(RailsHandler.INSTANCE)
.setResponseExample(Resources.getResource(this.getClass(), "example-search.json"));
- addProjectParam(search);
+ addProjectParam(action);
+ addFormatParam(action);
+ }
- WebService.NewAction create = controller.createAction("create")
+ private void defineCreateAction(NewController controller) {
+ WebService.NewAction action = controller.createAction("create")
.setDescription("Create an action plan. Requires Administer permission on project")
.setSince("3.6")
.setPost(true)
.setHandler(RailsHandler.INSTANCE);
- addNameParam(create);
- addDescriptionParam(create);
- addDeadLineParam(create);
- addProjectParam(create);
+ addNameParam(action);
+ addDescriptionParam(action);
+ addDeadLineParam(action);
+ addProjectParam(action);
+ addFormatParam(action);
+ }
- WebService.NewAction update = controller.createAction("update")
+ private void defineUpdateAction(NewController controller) {
+ WebService.NewAction action = controller.createAction("update")
.setDescription("Update an action plan. Requires Administer permission on project")
.setSince("3.6")
.setPost(true)
.setHandler(RailsHandler.INSTANCE);
- addKeyParam(update);
- addNameParam(update);
- addDescriptionParam(update);
- addDeadLineParam(update);
+ addKeyParam(action);
+ addNameParam(action);
+ addDescriptionParam(action);
+ addDeadLineParam(action);
+ addFormatParam(action);
+ }
- WebService.NewAction delete = controller.createAction("delete")
+ private void defineDeleteAction(NewController controller) {
+ WebService.NewAction action = controller.createAction("delete")
.setDescription("Delete an action plan. Requires Administer permission on project")
.setSince("3.6")
.setPost(true)
.setHandler(RailsHandler.INSTANCE);
- addKeyParam(delete);
+ addKeyParam(action);
+ addFormatParam(action);
+ }
- WebService.NewAction open = controller.createAction("open")
+ private void defineOpenAction(NewController controller) {
+ WebService.NewAction action = controller.createAction("open")
.setDescription("Open an action plan. Requires Administer permission on project")
.setSince("3.6")
.setPost(true)
.setHandler(RailsHandler.INSTANCE);
- addKeyParam(open);
+ addKeyParam(action);
+ addFormatParam(action);
+ }
- WebService.NewAction close = controller.createAction("close")
+ private void defineCloseAction(NewController controller) {
+ WebService.NewAction action = controller.createAction("close")
.setDescription("Close an action plan. Requires Administer permission on project")
.setSince("3.6")
.setPost(true)
.setHandler(RailsHandler.INSTANCE);
- addKeyParam(close);
-
- controller.done();
+ addKeyParam(action);
+ addFormatParam(action);
}
private static NewParam addKeyParam(WebService.NewAction action) {
.setExampleValue("org.codehaus.sonar:sonar")
.setRequired(true);
}
+
+ private static NewParam addFormatParam(WebService.NewAction action) {
+ return RailsHandler.addFormatParam(action);
+ }
}
showHandler.define(controller);
defineSearchAction(controller);
+ defineChangelogAction(controller);
defineAssignAction(controller);
defineAddCommentAction(controller);
defineDeleteCommentAction(controller);
defineEditCommentAction(controller);
- defineChangeSeverityAction(controller);
+ defineSetSeverityAction(controller);
definePlanAction(controller);
defineDoTransitionAction(controller);
defineTransitionsAction(controller);
defineCreateAction(controller);
+ defineDoActionAction(controller);
defineBulkChangeAction(controller);
controller.done();
.setDescription("Index of the selected page")
.setDefaultValue("1")
.setExampleValue("2");
+ RailsHandler.addFormatParam(action);
+ }
+
+ private void defineChangelogAction(NewController controller) {
+ WebService.NewAction action = controller.createAction("changelog")
+ .setDescription("Display changelog of an issue")
+ .setSince("4.1")
+ .setHandler(RailsHandler.INSTANCE)
+ .setResponseExample(Resources.getResource(this.getClass(), "example-changelog.json"));
+
+ action.createParam("issue")
+ .setDescription("Key of the issue")
+ .setRequired(true)
+ .setExampleValue("5bccd6e8-f525-43a2-8d76-fcb13dde79ef");
+ RailsHandler.addFormatParam(action);
}
private void defineAssignAction(NewController controller) {
action.createParam("assignee")
.setDescription("Login of the assignee")
.setExampleValue("admin");
+ RailsHandler.addFormatParam(action);
}
private void defineAddCommentAction(NewController controller) {
action.createParam("text")
.setDescription("Comment")
.setExampleValue("blabla...");
+ RailsHandler.addFormatParam(action);
}
private void defineDeleteCommentAction(NewController controller) {
action.createParam("text")
.setDescription("New comment")
.setExampleValue("blabla2...");
+ RailsHandler.addFormatParam(action);
}
- private void defineChangeSeverityAction(NewController controller) {
+ private void defineSetSeverityAction(NewController controller) {
WebService.NewAction action = controller.createAction("set_severity")
.setDescription("Change severity. Requires authentication and Browse permission on project")
.setSince("3.6")
.setDescription("New severity")
.setExampleValue(Severity.BLOCKER)
.setPossibleValues(Severity.ALL);
+ RailsHandler.addFormatParam(action);
}
private void definePlanAction(NewController controller) {
action.createParam("plan")
.setDescription("Key of the action plan")
.setExampleValue("3f19de90-1521-4482-a737-a311758ff513");
+ RailsHandler.addFormatParam(action);
}
private void defineDoTransitionAction(NewController controller) {
.setDescription("Transition")
.setExampleValue("reopen")
.setPossibleValues(DefaultTransitions.ALL);
+ RailsHandler.addFormatParam(action);
}
private void defineTransitionsAction(NewController controller) {
action.createParam("message")
.setDescription("Description of the issue")
.setExampleValue("blabla...");
+ RailsHandler.addFormatParam(action);
+ }
+
+ private void defineDoActionAction(NewController controller) {
+ WebService.NewAction action = controller.createAction("do_action")
+ .setDescription("Do workflow transition on an issue. Requires authentication and Browse permission on project")
+ .setSince("3.6")
+ .setHandler(RailsHandler.INSTANCE)
+ .setPost(true);
+
+ action.createParam("issue")
+ .setDescription("Key of the issue")
+ .setRequired(true)
+ .setExampleValue("5bccd6e8-f525-43a2-8d76-fcb13dde79ef");
+ action.createParam("actionKey")
+ .setDescription("Action to perform")
+ .setExampleValue("link-to-jira");
+ RailsHandler.addFormatParam(action);
}
private void defineBulkChangeAction(NewController controller) {
.setDescription("Available since version 4.0")
.setDefaultValue("false")
.setBooleanPossibleValues();
+ RailsHandler.addFormatParam(action);
}
}
action.createParam("toDateTime")
.setDescription("ISO-8601 datetime (inclusive)")
.setExampleValue("2010-12-25T23:59:59+0100");
+
+ action.createParam("format")
+ .setDescription("Response format")
+ .setPossibleValues("json", "csv");
}
}
action.createParam("component")
.setDescription("Key of the project. Required if a project permission is set. Available since version 4.0")
.setExampleValue("org.codehaus.sonar");
+ RailsHandler.addFormatParam(action);
}
private void defineRemoveAction(NewController controller) {
action.createParam("component")
.setDescription("Key of the project. Required if a project permission is set. Available since version 4.0")
.setExampleValue("org.codehaus.sonar");
+ RailsHandler.addFormatParam(action);
}
}
.setDescription("Get system properties and upgrade db")
.setSince("2.10");
+ defineIndexAction(controller);
defineSystemAction(controller);
defineSetupAction(controller);
controller.done();
}
+ private void defineIndexAction(NewController controller) {
+ NewAction action = controller.createAction("index")
+ .setDescription("Get the server status:" +
+ "<ul>" +
+ "<li>UP</li>" +
+ "<li>DOWN (generally for database connection failures)</li>" +
+ "<li>SETUP (if the server must be upgraded)</li>" +
+ "<li>MIGRATION_RUNNING (the upgrade process is currently running)</li>" +
+ "</ul>")
+ .setSince("2.10")
+ .setHandler(RailsHandler.INSTANCE)
+ .setResponseExample(Resources.getResource(this.getClass(), "example-index.json"));
+
+ RailsHandler.addFormatParam(action);
+ }
+
private void defineSystemAction(NewController controller) {
- controller.createAction("system")
+ NewAction action = controller.createAction("system")
.setDescription("Get the system properties, server info (Java, OS), database configuration, JVM statistics and installed plugins. Requires Administer System permission")
.setSince("2.10")
.setHandler(RailsHandler.INSTANCE)
.setResponseExample(Resources.getResource(this.getClass(), "example-system.json"));
+
+ RailsHandler.addFormatParam(action);
}
private void defineSetupAction(NewController controller) {
- controller.createAction("setup")
+ NewAction action = controller.createAction("setup")
.setDescription("Upgrade the SonarQube database")
.setSince("2.10")
.setPost(true)
.setHandler(RailsHandler.INSTANCE)
.setResponseExample(Resources.getResource(this.getClass(), "example-setup.json"));
+
+ action.createParam("format")
+ .setDescription("Response format")
+ .setPossibleValues("json", "csv", "text");
}
}
.setDescription("Former quality profiles web service");
defineListAction(controller);
+ defineIndexAction(controller);
defineBackupAction(controller);
defineRestoreAction(controller);
defineDestroyAction(controller);
action.createParam("project")
.setDescription("Project key or id")
.setExampleValue("org.codehaus.sonar:sonar");
+ RailsHandler.addJsonOnlyFormatParam(action);
+ }
+
+ private void defineIndexAction(NewController controller) {
+ WebService.NewAction action = controller.createAction("index")
+ .setDescription("Get a profile")
+ .setSince("3.3")
+ .setHandler(RailsHandler.INSTANCE)
+ .setResponseExample(Resources.getResource(this.getClass(), "example-index.json"));
+
+ action.createParam("language")
+ .setDescription("Profile language")
+ .setRequired(true)
+ .setExampleValue("java");
+ action.createParam("name")
+ .setDescription("Profile name. If no profile name is given, default profile for the given language will be returned")
+ .setExampleValue("Sonar way");
+ RailsHandler.addFormatParam(action);
}
private void defineBackupAction(NewController controller) {
action.createParam("name")
.setDescription("Profile name. If not set, the default profile for the selected language is used")
.setExampleValue("Sonar way");
+ RailsHandler.addFormatParam(action);
}
private void defineRestoreAction(NewController controller) {
action.createParam("backup")
.setRequired(true)
.setDescription("Path to the file containing the backup (HTML format)");
+ RailsHandler.addJsonOnlyFormatParam(action);
}
private void defineDestroyAction(NewController controller) {
.setRequired(true)
.setDescription("id or key of the test resource")
.setExampleValue("org.codehaus.sonar.plugins:sonar-cpd-plugin:src/test/java/org/sonar/plugins/cpd/SonarBridgeEngineTest.java");
+ RailsHandler.addJsonOnlyFormatParam(action);
}
private void defineTestableAction(NewController controller) {
.setRequired(true)
.setDescription("id or key of the resource")
.setExampleValue("org.codehaus.sonar.plugins:sonar-cpd-plugin:src/main/java/org/sonar/plugins/cpd/SonarBridgeEngine.java");
+ RailsHandler.addJsonOnlyFormatParam(action);
}
}
}
private void defineInstalledPluginsAction(NewController controller) {
- controller.createAction("installed_plugins")
+ NewAction action = controller.createAction("installed_plugins")
.setDescription("Get the list of all the plugins installed on the SonarQube instance")
.setSince("2.10")
.setHandler(RailsHandler.INSTANCE)
.setResponseExample(Resources.getResource(this.getClass(), "example-installed_plugins.json"));
+ RailsHandler.addFormatParam(action);
}
}
action.createParam("logins")
.setDescription("Comma-separated list of user logins")
.setExampleValue("admin,sbrandhof");
+
+ RailsHandler.addFormatParam(action);
}
private void defineCreateAction(NewController controller) {
action.createParam("email")
.setDescription("User email")
.setExampleValue("myname@email.com");
+
+ RailsHandler.addFormatParam(action);
}
private void defineUpdateAction(NewController controller) {
action.createParam("email")
.setDescription("User email")
.setExampleValue("mynewname@email.com");
+
+ RailsHandler.addFormatParam(action);
}
private void defineDeactivateAction(NewController controller) {
.setDescription("User login")
.setRequired(true)
.setExampleValue("myuser");
+
+ RailsHandler.addFormatParam(action);
}
}
--- /dev/null
+{
+ "id": "30057",
+ "k": "org.jenkins-ci.plugins:sonar",
+ "nm": "Jenkins Sonar Plugin",
+ "sc": "PRJ",
+ "qu": "TRK"
+}
+
--- /dev/null
+{
+ "changelog": [
+ {
+ "creationDate": "2014-03-04T23:03:44+0100",
+ "diffs": [
+ {
+ "key": "technicalDebt",
+ "newValue": "2min"
+ }
+ ]
+ }
+ ]
+
+}
--- /dev/null
+{
+ "id": "20140507170538",
+ "version": "4.3",
+ "status": "UP"
+}
--- /dev/null
+[
+ {
+ "name": "Sonar way",
+ "language": "java",
+ "default": true,
+ "rules": [
+ {
+ "key": "DuplicatedBlocks",
+ "repo": "common-java",
+ "severity": "MAJOR"
+ },
+ {
+ "key": "InsufficientBranchCoverage",
+ "repo": "common-java",
+ "severity": "MAJOR",
+ "params": [
+ {
+ "key": "minimumBranchCoverageRatio",
+ "value": "65.0"
+ }
+ ]
+ },
+ {
+ "key": "S00105",
+ "repo": "squid",
+ "severity": "MINOR"
+ },
+ {
+ "key": "MethodCyclomaticComplexity",
+ "repo": "squid",
+ "severity": "MAJOR",
+ "params": [
+ {
+ "key": "max",
+ "value": "10"
+ }
+ ]
+ }
+ ]
+ }
+]
assertThat(validate).isNotNull();
assertThat(validate.handler()).isInstanceOf(RailsHandler.class);
assertThat(validate.responseExampleAsString()).isNotEmpty();
- assertThat(validate.params()).isEmpty();
+ assertThat(validate.params()).hasSize(1);
}
}
assertThat(action.isPost()).isFalse();
assertThat(action.handler()).isInstanceOf(RailsHandler.class);
assertThat(action.responseExampleAsString()).isNotEmpty();
- assertThat(action.params()).hasSize(1);
+ assertThat(action.params()).hasSize(2);
}
}
assertThat(action).isNotNull();
assertThat(action.handler()).isInstanceOf(RailsHandler.class);
assertThat(action.responseExampleAsString()).isNotEmpty();
- assertThat(action.params()).hasSize(7);
+ assertThat(action.params()).hasSize(8);
}
@Test
WebService.Action action = controller.action("create");
assertThat(action).isNotNull();
assertThat(action.handler()).isInstanceOf(RailsHandler.class);
- assertThat(action.params()).hasSize(2);
+ assertThat(action.responseExampleAsString()).isNotEmpty();
+ assertThat(action.params()).hasSize(3);
}
@Test
assertThat(action).isNotNull();
assertThat(action.handler()).isInstanceOf(RailsHandler.class);
assertThat(action.responseExampleAsString()).isNotEmpty();
- assertThat(action.params()).hasSize(10);
+ assertThat(action.params()).hasSize(11);
}
@Test
assertThat(action.handler()).isInstanceOf(RailsHandler.class);
assertThat(action.isInternal()).isTrue();
assertThat(action.responseExampleAsString()).isNotEmpty();
- assertThat(action.params()).hasSize(7);
+ assertThat(action.params()).hasSize(8);
}
}
assertThat(action).isNotNull();
assertThat(action.handler()).isInstanceOf(RailsHandler.class);
assertThat(action.responseExampleAsString()).isNotEmpty();
- assertThat(action.params()).hasSize(1);
+ assertThat(action.params()).hasSize(2);
}
@Test
WebService.Action action = controller.action("create");
assertThat(action).isNotNull();
assertThat(action.handler()).isInstanceOf(RailsHandler.class);
- assertThat(action.params()).hasSize(4);
+ assertThat(action.params()).hasSize(5);
}
@Test
WebService.Action action = controller.action("delete");
assertThat(action).isNotNull();
assertThat(action.handler()).isInstanceOf(RailsHandler.class);
- assertThat(action.params()).hasSize(1);
+ assertThat(action.params()).hasSize(2);
}
@Test
WebService.Action action = controller.action("update");
assertThat(action).isNotNull();
assertThat(action.handler()).isInstanceOf(RailsHandler.class);
- assertThat(action.params()).hasSize(4);
+ assertThat(action.params()).hasSize(5);
}
@Test
WebService.Action action = controller.action("open");
assertThat(action).isNotNull();
assertThat(action.handler()).isInstanceOf(RailsHandler.class);
- assertThat(action.params()).hasSize(1);
+ assertThat(action.params()).hasSize(2);
}
@Test
WebService.Action action = controller.action("close");
assertThat(action).isNotNull();
assertThat(action.handler()).isInstanceOf(RailsHandler.class);
- assertThat(action.params()).hasSize(1);
+ assertThat(action.params()).hasSize(2);
}
}
assertThat(controller).isNotNull();
assertThat(controller.description()).isNotEmpty();
assertThat(controller.since()).isEqualTo("3.6");
- assertThat(controller.actions()).hasSize(12);
+ assertThat(controller.actions()).hasSize(14);
}
@Test
assertThat(show.isInternal()).isFalse();
assertThat(show.handler()).isInstanceOf(RailsHandler.class);
assertThat(show.responseExampleAsString()).isNotEmpty();
- assertThat(show.params()).hasSize(17);
+ assertThat(show.params()).hasSize(18);
+ }
+
+ @Test
+ public void define_changelog_action() throws Exception {
+ WebService.Controller controller = tester.controller("api/issues");
+
+ WebService.Action action = controller.action("changelog");
+ assertThat(action).isNotNull();
+ assertThat(action.handler()).isNotNull();
+ assertThat(action.responseExampleAsString()).isNotEmpty();
+ assertThat(action.params()).hasSize(2);
}
@Test
assertThat(action.isPost()).isTrue();
assertThat(action.isInternal()).isFalse();
assertThat(action.handler()).isInstanceOf(RailsHandler.class);
- assertThat(action.params()).hasSize(2);
+ assertThat(action.params()).hasSize(3);
}
@Test
assertThat(action.isPost()).isTrue();
assertThat(action.isInternal()).isFalse();
assertThat(action.handler()).isInstanceOf(RailsHandler.class);
- assertThat(action.params()).hasSize(2);
+ assertThat(action.params()).hasSize(3);
}
@Test
assertThat(action.isPost()).isTrue();
assertThat(action.isInternal()).isFalse();
assertThat(action.handler()).isInstanceOf(RailsHandler.class);
- assertThat(action.params()).hasSize(2);
+ assertThat(action.params()).hasSize(3);
}
@Test
assertThat(action.isPost()).isTrue();
assertThat(action.isInternal()).isFalse();
assertThat(action.handler()).isInstanceOf(RailsHandler.class);
- assertThat(action.params()).hasSize(2);
+ assertThat(action.params()).hasSize(3);
}
@Test
assertThat(action.isPost()).isTrue();
assertThat(action.isInternal()).isFalse();
assertThat(action.handler()).isInstanceOf(RailsHandler.class);
- assertThat(action.params()).hasSize(2);
+ assertThat(action.params()).hasSize(3);
}
@Test
assertThat(action.isPost()).isTrue();
assertThat(action.isInternal()).isFalse();
assertThat(action.handler()).isInstanceOf(RailsHandler.class);
- assertThat(action.params()).hasSize(2);
+ assertThat(action.params()).hasSize(3);
}
@Test
assertThat(action.since()).isEqualTo("3.6");
assertThat(action.isPost()).isTrue();
assertThat(action.isInternal()).isFalse();
- assertThat(action.params()).hasSize(5);
+ assertThat(action.params()).hasSize(6);
+ }
+
+ @Test
+ public void define_do_action_action() throws Exception {
+ WebService.Controller controller = tester.controller("api/issues");
+
+ WebService.Action action = controller.action("do_action");
+ assertThat(action).isNotNull();
+ assertThat(action.handler()).isNotNull();
+ assertThat(action.since()).isEqualTo("3.6");
+ assertThat(action.isPost()).isTrue();
+ assertThat(action.isInternal()).isFalse();
+ assertThat(action.params()).hasSize(3);
}
@Test
assertThat(action.isPost()).isTrue();
assertThat(action.isInternal()).isFalse();
assertThat(action.handler()).isInstanceOf(RailsHandler.class);
- assertThat(action.params()).hasSize(8);
+ assertThat(action.params()).hasSize(9);
}
}
assertThat(action).isNotNull();
assertThat(action.handler()).isInstanceOf(RailsHandler.class);
assertThat(action.responseExampleAsString()).isNotEmpty();
- assertThat(action.params()).hasSize(4);
+ assertThat(action.params()).hasSize(5);
}
}
WebService.Action action = controller.action("add");
assertThat(action).isNotNull();
assertThat(action.handler()).isInstanceOf(RailsHandler.INSTANCE.getClass());
- assertThat(action.params()).hasSize(4);
+ assertThat(action.params()).hasSize(5);
WebService.Param permission = action.param("permission");
assertThat(permission).isNotNull();
WebService.Action action = controller.action("remove");
assertThat(action).isNotNull();
assertThat(action.handler()).isInstanceOf(RailsHandler.INSTANCE.getClass());
- assertThat(action.params()).hasSize(4);
+ assertThat(action.params()).hasSize(5);
}
}
assertThat(controller).isNotNull();
assertThat(controller.since()).isEqualTo("2.10");
assertThat(controller.description()).isNotEmpty();
- assertThat(controller.actions()).hasSize(2);
+ assertThat(controller.actions()).hasSize(3);
+ }
+
+ @Test
+ public void define_index_action() throws Exception {
+ WebService.Controller controller = tester.controller("api/server");
+
+ WebService.Action action = controller.action("index");
+ assertThat(action).isNotNull();
+ assertThat(action.handler()).isInstanceOf(RailsHandler.class);
+ assertThat(action.responseExampleAsString()).isNotEmpty();
+ assertThat(action.params()).hasSize(1);
}
@Test
assertThat(action).isNotNull();
assertThat(action.handler()).isInstanceOf(RailsHandler.class);
assertThat(action.responseExampleAsString()).isNotEmpty();
- assertThat(action.params()).isEmpty();
+ assertThat(action.params()).hasSize(1);
}
@Test
assertThat(action).isNotNull();
assertThat(action.handler()).isInstanceOf(RailsHandler.class);
assertThat(action.responseExampleAsString()).isNotEmpty();
- assertThat(action.params()).isEmpty();
+ assertThat(action.params()).hasSize(1);
}
}
assertThat(controller).isNotNull();
assertThat(controller.path()).isEqualTo("api/profiles");
assertThat(controller.description()).isNotEmpty();
- assertThat(controller.actions()).hasSize(5);
+ assertThat(controller.actions()).hasSize(6);
}
@Test
assertThat(restoreProfiles).isNotNull();
assertThat(restoreProfiles.handler()).isInstanceOf(RailsHandler.class);
assertThat(restoreProfiles.responseExampleAsString()).isNotEmpty();
- assertThat(restoreProfiles.params()).hasSize(2);
+ assertThat(restoreProfiles.params()).hasSize(3);
+ }
+
+ @Test
+ public void define_index_action() throws Exception {
+ WebService.Controller controller = tester.controller("api/profiles");
+
+ WebService.Action restoreProfiles = controller.action("index");
+ assertThat(restoreProfiles).isNotNull();
+ assertThat(restoreProfiles.handler()).isInstanceOf(RailsHandler.class);
+ assertThat(restoreProfiles.responseExampleAsString()).isNotEmpty();
+ assertThat(restoreProfiles.params()).hasSize(3);
}
@Test
WebService.Action restoreProfiles = controller.action("backup");
assertThat(restoreProfiles).isNotNull();
assertThat(restoreProfiles.handler()).isInstanceOf(RailsHandler.class);
- assertThat(restoreProfiles.params()).hasSize(2);
+ assertThat(restoreProfiles.params()).hasSize(3);
}
@Test
WebService.Action restoreProfiles = controller.action("restore");
assertThat(restoreProfiles).isNotNull();
assertThat(restoreProfiles.handler()).isInstanceOf(RailsHandler.class);
- assertThat(restoreProfiles.params()).hasSize(1);
+ assertThat(restoreProfiles.params()).hasSize(2);
}
@Test
assertThat(action.isPost()).isFalse();
assertThat(action.handler()).isInstanceOf(RailsHandler.class);
assertThat(action.responseExampleAsString()).isNotEmpty();
- assertThat(action.params()).hasSize(1);
+ assertThat(action.params()).hasSize(2);
}
@Test
assertThat(action.isPost()).isFalse();
assertThat(action.handler()).isInstanceOf(RailsHandler.class);
assertThat(action.responseExampleAsString()).isNotEmpty();
- assertThat(action.params()).hasSize(1);
+ assertThat(action.params()).hasSize(2);
}
}
assertThat(action).isNotNull();
assertThat(action.handler()).isInstanceOf(RailsHandler.class);
assertThat(action.responseExampleAsString()).isNotEmpty();
- assertThat(action.params()).isEmpty();
+ assertThat(action.params()).hasSize(1);
}
}
assertThat(action.isPost()).isFalse();
assertThat(action.handler()).isInstanceOf(RailsHandler.class);
assertThat(action.responseExampleAsString()).isNotEmpty();
- assertThat(action.params()).hasSize(2);
+ assertThat(action.params()).hasSize(3);
}
@Test
assertThat(action).isNotNull();
assertThat(action.isPost()).isTrue();
assertThat(action.handler()).isInstanceOf(RailsHandler.class);
- assertThat(action.params()).hasSize(5);
+ assertThat(action.params()).hasSize(6);
}
@Test
assertThat(action).isNotNull();
assertThat(action.isPost()).isTrue();
assertThat(action.handler()).isInstanceOf(RailsHandler.class);
- assertThat(action.params()).hasSize(3);
+ assertThat(action.params()).hasSize(4);
}
@Test
assertThat(action).isNotNull();
assertThat(action.isPost()).isTrue();
assertThat(action.handler()).isInstanceOf(RailsHandler.class);
- assertThat(action.params()).hasSize(1);
+ assertThat(action.params()).hasSize(2);
}
}