import org.sonar.api.server.ws.WebService.NewAction;
import org.sonar.api.server.ws.WebService.Param;
import org.sonar.api.utils.text.JsonWriter;
+import org.sonar.server.ws.WsAction;
/**
* @since 5.1
*/
-public class ListAction implements RequestHandler {
+public class ListAction implements RequestHandler, WsAction {
private static final String MATCH_ALL = ".*";
private final Languages languages;
}
}
- void define(WebService.NewController controller) {
+ public void define(WebService.NewController controller) {
NewAction action = controller.createAction("list")
.setDescription("List supported programming languages")
.setSince("5.1")
*/
package org.sonar.server.authentication.ws;
-import java.util.Arrays;
+import java.util.Collections;
import org.junit.Test;
import org.sonar.api.server.ws.WebService;
-import org.sonar.server.ws.ServletFilterHandler;
-import org.sonar.server.ws.WsTester;
import static org.assertj.core.api.Assertions.assertThat;
public class AuthenticationWsTest {
-
- WsTester tester = new WsTester(new AuthenticationWs(Arrays.asList(
- new LoginAction(null, null, null, null, null),
- new LogoutAction(null, null),
- new ValidateAction(null, null, null))));
+ private AuthenticationWs underTest = new AuthenticationWs(Collections.singletonList(new AuthenticationWsAction() {
+ @Override
+ public void define(WebService.NewController controller) {
+ controller.createAction("foo")
+ .setHandler((request, response) -> {
+ throw new UnsupportedOperationException("not implemented");
+ });
+ }
+ }));
@Test
public void define_ws() {
- WebService.Controller controller = tester.controller("api/authentication");
- assertThat(controller).isNotNull();
- assertThat(controller.description()).isNotEmpty();
- assertThat(controller.actions()).hasSize(3);
+ WebService.Context context = new WebService.Context();
- WebService.Action validate = controller.action("validate");
- assertThat(validate).isNotNull();
- assertThat(validate.handler()).isInstanceOf(ServletFilterHandler.class);
- assertThat(validate.responseExampleAsString()).isNotEmpty();
- assertThat(validate.params()).isEmpty();
+ underTest.define(context);
- WebService.Action login = controller.action("login");
- assertThat(login).isNotNull();
- assertThat(login.handler()).isInstanceOf(ServletFilterHandler.class);
- assertThat(login.isPost()).isTrue();
- assertThat(login.params()).hasSize(2);
+ WebService.Controller controller = context.controller("api/authentication");
+ assertThat(controller).isNotNull();
+ assertThat(controller.description()).isNotEmpty();
+ assertThat(controller.actions()).hasSize(1);
- WebService.Action logout = controller.action("logout");
- assertThat(logout).isNotNull();
- assertThat(logout.handler()).isInstanceOf(ServletFilterHandler.class);
- assertThat(logout.isPost()).isTrue();
- assertThat(logout.params()).isEmpty();
+ WebService.Action fooAction = controller.action("foo");
+ assertThat(fooAction).isNotNull();
+ assertThat(fooAction.handler()).isNotNull();
}
}
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
+import org.sonar.api.server.ws.WebService;
import org.sonar.api.utils.System2;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import org.sonar.server.exceptions.UnauthorizedException;
import org.sonar.server.user.TestUserSessionFactory;
import org.sonar.server.user.ThreadLocalUserSession;
+import org.sonar.server.ws.ServletFilterHandler;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
dbSession.commit();
}
+ @Test
+ public void verify_definition() {
+ String controllerKey = "foo";
+ WebService.Context context = new WebService.Context();
+ WebService.NewController newController = context.createController(controllerKey);
+ underTest.define(newController);
+ newController.done();
+
+ WebService.Action login = context.controller(controllerKey).action("login");
+ assertThat(login).isNotNull();
+ assertThat(login.handler()).isInstanceOf(ServletFilterHandler.class);
+ assertThat(login.isPost()).isTrue();
+ assertThat(login.params()).hasSize(2);
+ }
+
@Test
public void do_get_pattern() {
assertThat(underTest.doGetPattern().matches("/api/authentication/login")).isTrue();
import javax.servlet.http.HttpServletResponse;
import org.junit.Rule;
import org.junit.Test;
+import org.sonar.api.server.ws.WebService;
import org.sonar.api.utils.System2;
import org.sonar.db.DbTester;
import org.sonar.db.user.UserDto;
import org.sonar.server.authentication.JwtHttpHandler;
import org.sonar.server.authentication.event.AuthenticationEvent;
import org.sonar.server.authentication.event.AuthenticationException;
+import org.sonar.server.ws.ServletFilterHandler;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
private LogoutAction underTest = new LogoutAction(jwtHttpHandler, authenticationEvent);
+ @Test
+ public void verify_definition() {
+ String controllerKey = "foo";
+ WebService.Context context = new WebService.Context();
+ WebService.NewController newController = context.createController(controllerKey);
+ underTest.define(newController);
+ newController.done();
+
+ WebService.Action logout = context.controller(controllerKey).action("logout");
+ assertThat(logout).isNotNull();
+ assertThat(logout.handler()).isInstanceOf(ServletFilterHandler.class);
+ assertThat(logout.isPost()).isTrue();
+ assertThat(logout.params()).isEmpty();
+ }
+
@Test
public void do_get_pattern() {
assertThat(underTest.doGetPattern().matches("/api/authentication/logout")).isTrue();
import org.junit.Before;
import org.junit.Test;
import org.sonar.api.config.internal.MapSettings;
+import org.sonar.api.server.ws.WebService;
import org.sonar.server.authentication.BasicAuthentication;
import org.sonar.server.authentication.JwtHttpHandler;
import org.sonar.server.authentication.event.AuthenticationException;
+import org.sonar.server.ws.ServletFilterHandler;
import org.sonar.test.JsonAssert;
import org.sonarqube.ws.MediaTypes;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
when(response.getWriter()).thenReturn(writer);
}
+ @Test
+ public void verify_definition() {
+ String controllerKey = "foo";
+ WebService.Context context = new WebService.Context();
+ WebService.NewController newController = context.createController(controllerKey);
+ underTest.define(newController);
+ newController.done();
+
+ WebService.Action validate = context.controller(controllerKey).action("validate");
+ assertThat(validate).isNotNull();
+ assertThat(validate.handler()).isInstanceOf(ServletFilterHandler.class);
+ assertThat(validate.responseExampleAsString()).isNotEmpty();
+ assertThat(validate.params()).isEmpty();
+ }
+
@Test
public void return_true_when_jwt_token_is_set() throws Exception {
when(jwtHttpHandler.validateToken(request, response)).thenReturn(Optional.of(newUserDto()));
package org.sonar.server.favorite.ws;
import org.junit.Test;
-import org.sonar.api.server.ws.WebService.Controller;
-import org.sonar.db.DbClient;
-import org.sonar.server.component.ComponentFinder;
-import org.sonar.server.favorite.FavoriteUpdater;
-import org.sonar.server.user.UserSession;
-import org.sonar.server.ws.WsTester;
+import org.sonar.api.server.ws.Request;
+import org.sonar.api.server.ws.Response;
+import org.sonar.api.server.ws.WebService;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
public class FavoritesWsTest {
- private final FavoritesWsAction[] actions = {new AddAction(mock(UserSession.class), mock(DbClient.class), mock(FavoriteUpdater.class), mock(ComponentFinder.class))};
- private WsTester ws = new WsTester(new FavoritesWs(actions));
+ private final FavoritesWsAction[] actions = {new FavoritesWsAction() {
+ @Override
+ public void define(WebService.NewController context) {
+ context.createAction("foo").setHandler(this);
+ }
- private Controller underTest = ws.controller("api/favorites");
+ @Override
+ public void handle(Request request, Response response) {
+
+ }
+ }};
+ private FavoritesWs underTest = new FavoritesWs(actions);
@Test
public void definition() {
- assertThat(underTest.path()).isEqualTo("api/favorites");
+ WebService.Context context = new WebService.Context();
+
+ underTest.define(context);
+
+ assertThat(context.controller("api/favorites")).isNotNull();
}
}
*/
package org.sonar.server.language.ws;
-import org.junit.Before;
import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
-import org.sonar.api.resources.AbstractLanguage;
-import org.sonar.api.resources.Language;
-import org.sonar.api.resources.Languages;
+import org.sonar.api.server.ws.WebService;
import org.sonar.api.server.ws.WebService.Action;
import org.sonar.api.server.ws.WebService.Controller;
-import org.sonar.server.ws.WsTester;
import static org.assertj.core.api.Assertions.assertThat;
-@RunWith(MockitoJUnitRunner.class)
public class LanguageWsTest {
private static final String CONTROLLER_LANGUAGES = "api/languages";
private static final String ACTION_LIST = "list";
- private static final String EMPTY_JSON_RESPONSE = "{\"languages\": []}";
- @Mock
- private Languages languages;
-
- private WsTester tester;
-
- @Before
- public void setUp() {
- Mockito.when(languages.all()).thenReturn(new Language[] {
- new Ook(),
- new LolCode(),
- new Whitespace(),
- new ArnoldC()
- });
- tester = new WsTester(new LanguageWs(new ListAction(languages)));
- }
+ private LanguageWs underTest = new LanguageWs(new ListAction(null));
@Test
public void should_be_well_defined() {
- Controller controller = tester.controller(CONTROLLER_LANGUAGES);
+ WebService.Context context = new WebService.Context();
+
+ underTest.define(context);
+
+ Controller controller = context.controller(CONTROLLER_LANGUAGES);
assertThat(controller).isNotNull();
assertThat(controller.description()).isNotEmpty();
assertThat(controller.isInternal()).isFalse();
assertThat(list.responseExampleAsString()).isNotEmpty();
assertThat(list.params()).hasSize(2);
}
-
- @Test
- public void list_all_languages() throws Exception {
- tester.newGetRequest(CONTROLLER_LANGUAGES, ACTION_LIST).execute().assertJson(this.getClass(), "list.json");
-
- tester.newGetRequest(CONTROLLER_LANGUAGES, ACTION_LIST)
- .setParam("ps", "2")
- .execute().assertJson(this.getClass(), "list_limited.json");
- tester.newGetRequest(CONTROLLER_LANGUAGES, ACTION_LIST)
- .setParam("ps", "4")
- .execute().assertJson(this.getClass(), "list.json");
- tester.newGetRequest(CONTROLLER_LANGUAGES, ACTION_LIST)
- .setParam("ps", "10")
- .execute().assertJson(this.getClass(), "list.json");
- }
-
- @Test
- public void filter_languages_by_key_or_name() throws Exception {
- tester.newGetRequest(CONTROLLER_LANGUAGES, ACTION_LIST)
- .setParam("q", "ws")
- .execute().assertJson(this.getClass(), "list_filtered_key.json");
- tester.newGetRequest(CONTROLLER_LANGUAGES, ACTION_LIST)
- .setParam("q", "o")
- .execute().assertJson(this.getClass(), "list_filtered_name.json");
- }
-
- /**
- * Potential vulnerability : the query provided by user must
- * not be executed as a regexp.
- */
- @Test
- public void filter_escapes_the_user_query() throws Exception {
- // invalid regexp
- tester.newGetRequest(CONTROLLER_LANGUAGES, ACTION_LIST)
- .setParam("q", "[")
- .execute().assertJson(EMPTY_JSON_RESPONSE);
-
- // do not consider param as a regexp
- tester.newGetRequest(CONTROLLER_LANGUAGES, ACTION_LIST)
- .setParam("q", ".*")
- .execute().assertJson(EMPTY_JSON_RESPONSE);
- }
-
- static abstract class TestLanguage extends AbstractLanguage {
- TestLanguage(String key, String language) {
- super(key, language);
- }
-
- @Override
- public String[] getFileSuffixes() {
- return new String[0];
- }
- }
-
- static class Ook extends TestLanguage {
- public Ook() {
- super("ook", "Ook!");
- }
- }
-
- static class LolCode extends TestLanguage {
- public LolCode() {
- super("lol", "LOLCODE");
- }
- }
-
- static class Whitespace extends TestLanguage {
- public Whitespace() {
- super("ws", "Whitespace");
- }
- }
-
- static class ArnoldC extends TestLanguage {
- public ArnoldC() {
- super("ac", "ArnoldC");
- }
- }
}
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2019 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+package org.sonar.server.language.ws;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.sonar.api.resources.AbstractLanguage;
+import org.sonar.api.resources.Language;
+import org.sonar.api.resources.Languages;
+import org.sonar.server.ws.WsActionTester;
+
+import static org.mockito.Mockito.mock;
+
+public class ListActionTest {
+ private static final String EMPTY_JSON_RESPONSE = "{\"languages\": []}";
+
+ private Languages languages = mock(Languages.class);
+ private ListAction underTest = new ListAction(languages);
+ private WsActionTester tester = new WsActionTester(underTest);
+
+ @Before
+ public void setUp() {
+ Mockito.when(languages.all()).thenReturn(new Language[] {
+ new Ook(),
+ new LolCode(),
+ new Whitespace(),
+ new ArnoldC()
+ });
+ }
+
+ @Test
+ public void list_all_languages() {
+ tester.newRequest().execute().assertJson(this.getClass(), "list.json");
+
+ tester.newRequest()
+ .setParam("ps", "2")
+ .execute().assertJson(this.getClass(), "list_limited.json");
+ tester.newRequest()
+ .setParam("ps", "4")
+ .execute().assertJson(this.getClass(), "list.json");
+ tester.newRequest()
+ .setParam("ps", "10")
+ .execute().assertJson(this.getClass(), "list.json");
+ }
+
+ @Test
+ public void filter_languages_by_key_or_name() {
+ tester.newRequest()
+ .setParam("q", "ws")
+ .execute().assertJson(this.getClass(), "list_filtered_key.json");
+ tester.newRequest()
+ .setParam("q", "o")
+ .execute().assertJson(this.getClass(), "list_filtered_name.json");
+ }
+
+ /**
+ * Potential vulnerability : the query provided by user must
+ * not be executed as a regexp.
+ */
+ @Test
+ public void filter_escapes_the_user_query() {
+ // invalid regexp
+ tester.newRequest()
+ .setParam("q", "[")
+ .execute().assertJson(EMPTY_JSON_RESPONSE);
+
+ // do not consider param as a regexp
+ tester.newRequest()
+ .setParam("q", ".*")
+ .execute().assertJson(EMPTY_JSON_RESPONSE);
+ }
+
+ static abstract class TestLanguage extends AbstractLanguage {
+ TestLanguage(String key, String language) {
+ super(key, language);
+ }
+
+ @Override
+ public String[] getFileSuffixes() {
+ return new String[0];
+ }
+ }
+
+ static class Ook extends TestLanguage {
+ Ook() {
+ super("ook", "Ook!");
+ }
+ }
+
+ static class LolCode extends TestLanguage {
+ LolCode() {
+ super("lol", "LOLCODE");
+ }
+ }
+
+ static class Whitespace extends TestLanguage {
+ Whitespace() {
+ super("ws", "Whitespace");
+ }
+ }
+
+ static class ArnoldC extends TestLanguage {
+ ArnoldC() {
+ super("ac", "ArnoldC");
+ }
+ }
+}
*/
package org.sonar.server.measure.custom.ws;
-import org.junit.Before;
import org.junit.Test;
+import org.sonar.api.server.ws.Request;
+import org.sonar.api.server.ws.Response;
import org.sonar.api.server.ws.WebService;
-import org.sonar.api.utils.System2;
-import org.sonar.db.DbClient;
-import org.sonar.server.component.ComponentFinder;
-import org.sonar.server.user.UserSession;
-import org.sonar.server.ws.WsTester;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
-import static org.sonar.server.measure.custom.ws.CustomMeasuresWs.ENDPOINT;
public class CustomMeasuresWsTest {
- WsTester ws;
+ private CustomMeasuresWs underTest = new CustomMeasuresWs(new CustomMeasuresWsAction() {
+ @Override
+ public void define(WebService.NewController context) {
+ context.createAction("foo").setHandler(this);
+ }
- @Before
- public void setUp() {
- DbClient dbClient = mock(DbClient.class);
- UserSession userSession = mock(UserSession.class);
- ws = new WsTester(new CustomMeasuresWs(
- new DeleteAction(dbClient, userSession),
- new CreateAction(dbClient, userSession, System2.INSTANCE, mock(CustomMeasureValidator.class), mock(CustomMeasureJsonWriter.class), mock(ComponentFinder.class)),
- new UpdateAction(dbClient, userSession, System2.INSTANCE, mock(CustomMeasureValidator.class), mock(CustomMeasureJsonWriter.class))
- ));
- }
+ @Override
+ public void handle(Request request, Response response) {
+
+ }
+ });
@Test
public void define_ws() {
- WebService.Controller controller = ws.controller("api/custom_measures");
- assertThat(controller).isNotNull();
- assertThat(controller.description()).isNotEmpty();
- assertThat(controller.actions()).hasSize(3);
- }
+ WebService.Context context = new WebService.Context();
- @Test
- public void delete_action_properties() {
- WebService.Action deleteAction = ws.controller(ENDPOINT).action("delete");
- assertThat(deleteAction.isPost()).isTrue();
- }
+ underTest.define(context);
- @Test
- public void create_action_properties() {
- WebService.Action action = ws.controller(ENDPOINT).action("create");
- assertThat(action.isPost()).isTrue();
+ WebService.Controller controller = context.controller("api/custom_measures");
+ assertThat(controller).isNotNull();
+ assertThat(controller.description()).isNotEmpty();
+ assertThat(controller.actions()).hasSize(1);
}
- @Test
- public void create_update_properties() {
- WebService.Action action = ws.controller(ENDPOINT).action("update");
- assertThat(action.isPost()).isTrue();
- }
}
*/
package org.sonar.server.measure.custom.ws;
-import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.exceptions.UnauthorizedException;
import org.sonar.server.tester.UserSessionRule;
-import org.sonar.server.ws.WsTester;
+import org.sonar.server.ws.WsActionTester;
import static java.lang.String.valueOf;
import static org.assertj.core.api.Assertions.assertThat;
public class DeleteActionTest {
- public static final String ACTION = "delete";
-
@Rule
public UserSessionRule userSession = UserSessionRule.standalone();
@Rule
private DbClient dbClient = db.getDbClient();
private final DbSession dbSession = db.getSession();
- private WsTester ws;
-
- @Before
- public void setUp() {
- ws = new WsTester(new CustomMeasuresWs(new DeleteAction(dbClient, userSession)));
- }
+ private DeleteAction underTest = new DeleteAction(dbClient, userSession);
+ private WsActionTester tester = new WsActionTester(underTest);
@Test
- public void project_administrator_can_delete_custom_measures() throws Exception {
+ public void project_administrator_can_delete_custom_measures() {
ComponentDto project = db.components().insertPrivateProject();
userSession.logIn().addProjectPermission(UserRole.ADMIN, project);
long id = insertCustomMeasure(project);
- newRequest().setParam(PARAM_ID, valueOf(id)).execute();
+ tester.newRequest().setParam(PARAM_ID, valueOf(id)).execute();
assertThat(dbClient.customMeasureDao().selectById(dbSession, id)).isNull();
}
@Test
- public void throw_RowNotFoundException_if_id_does_not_exist() throws Exception {
+ public void throw_RowNotFoundException_if_id_does_not_exist() {
expectedException.expect(IllegalArgumentException.class);
expectedException.expectMessage("Custom measure with id '42' does not exist");
- newRequest().setParam(PARAM_ID, "42").execute();
+ tester.newRequest().setParam(PARAM_ID, "42").execute();
}
@Test
- public void throw_ForbiddenException_if_not_system_administrator() throws Exception {
+ public void throw_ForbiddenException_if_not_system_administrator() {
ComponentDto project = db.components().insertPrivateProject();
long id = insertCustomMeasure(project);
userSession.logIn().setNonSystemAdministrator();
expectedException.expect(ForbiddenException.class);
- newRequest().setParam(PARAM_ID, valueOf(id)).execute();
+ tester.newRequest().setParam(PARAM_ID, valueOf(id)).execute();
}
@Test
- public void throw_UnauthorizedException_if_not_logged_in() throws Exception {
+ public void throw_UnauthorizedException_if_not_logged_in() {
ComponentDto project = db.components().insertPrivateProject();
long id = insertCustomMeasure(project);
userSession.anonymous();
expectedException.expect(UnauthorizedException.class);
- newRequest().setParam(PARAM_ID, valueOf(id)).execute();
+ tester.newRequest().setParam(PARAM_ID, valueOf(id)).execute();
}
private long insertCustomMeasure(ComponentDto component) {
return dto.getId();
}
- private WsTester.TestRequest newRequest() {
- return ws.newPostRequest(CustomMeasuresWs.ENDPOINT, ACTION);
- }
}
import org.sonar.server.es.EsTester;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.tester.UserSessionRule;
-import org.sonar.server.ws.WsTester;
+import org.sonar.server.ws.TestResponse;
+import org.sonar.server.ws.WsActionTester;
import static org.assertj.core.api.Assertions.assertThat;
import static org.sonar.db.measure.custom.CustomMeasureTesting.newCustomMeasureDto;
import static org.sonar.db.metric.MetricTesting.newMetricDto;
-import static org.sonar.server.measure.custom.ws.CustomMeasuresWs.ENDPOINT;
-import static org.sonar.server.measure.custom.ws.MetricsAction.ACTION;
public class MetricsActionTest {
private static final String DEFAULT_PROJECT_UUID = "project-uuid";
private final DbClient dbClient = db.getDbClient();
private final DbSession dbSession = db.getSession();
private ComponentDto defaultProject;
- private WsTester ws;
+ private MetricsAction underTest = new MetricsAction(dbClient, userSession, TestComponentFinder.from(db));
+ private WsActionTester tester = new WsActionTester(underTest);
@Before
public void setUp() throws Exception {
defaultProject = insertDefaultProject();
userSession.logIn().addProjectPermission(UserRole.ADMIN, defaultProject);
- ws = new WsTester(new CustomMeasuresWs(new MetricsAction(dbClient, userSession, TestComponentFinder.from(db))));
}
@Test
- public void list_metrics() throws Exception {
+ public void list_metrics() {
insertCustomMetric("metric-key-1");
insertCustomMetric("metric-key-2");
insertCustomMetric("metric-key-3");
- String response = newRequest().outputAsString();
+ String response = newRequest().getInput();
assertThat(response).contains("metric-key-1", "metric-key-2", "metric-key-3");
}
@Test
- public void list_metrics_active_and_custom_only() throws Exception {
+ public void list_metrics_active_and_custom_only() {
insertCustomMetric("metric-key-1");
dbClient.metricDao().insert(dbSession, newMetricDto().setEnabled(true).setUserManaged(false).setKey("metric-key-2"));
dbClient.metricDao().insert(dbSession, newMetricDto().setEnabled(false).setUserManaged(true).setKey("metric-key-3"));
dbSession.commit();
- String response = newRequest().outputAsString();
+ String response = newRequest().getInput();
assertThat(response).contains("metric-key-1")
.doesNotContain("metric-key-2")
}
@Test
- public void list_metrics_where_no_existing_custom_measure() throws Exception {
+ public void list_metrics_where_no_existing_custom_measure() {
MetricDto metric = insertCustomMetric("metric-key-1");
insertCustomMetric("metric-key-2");
insertProject("project-uuid-2", "project-key-2");
dbClient.customMeasureDao().insert(dbSession, customMeasure);
dbSession.commit();
- String response = newRequest().outputAsString();
+ String response = newRequest().getInput();
assertThat(response).contains("metric-key-2")
.doesNotContain("metric-key-1");
}
@Test
- public void list_metrics_based_on_project_key() throws Exception {
+ public void list_metrics_based_on_project_key() {
MetricDto metric = insertCustomMetric("metric-key-1");
insertCustomMetric("metric-key-2");
insertProject("project-uuid-2", "project-key-2");
dbClient.customMeasureDao().insert(dbSession, customMeasure);
dbSession.commit();
- String response = ws.newGetRequest(ENDPOINT, ACTION)
+ String response = tester.newRequest()
.setParam(MetricsAction.PARAM_PROJECT_KEY, DEFAULT_PROJECT_KEY)
- .execute().outputAsString();
+ .execute().getInput();
assertThat(response).contains("metric-key-2")
.doesNotContain("metric-key-1");
}
@Test
- public void list_metrics_as_a_project_admin() throws Exception {
+ public void list_metrics_as_a_project_admin() {
insertCustomMetric("metric-key-1");
userSession.logIn("login").addProjectPermission(UserRole.ADMIN, defaultProject);
- String response = newRequest().outputAsString();
+ String response = newRequest().getInput();
assertThat(response).contains("metric-key-1");
}
@Test
- public void response_with_correct_formatting() throws Exception {
+ public void response_with_correct_formatting() {
dbClient.metricDao().insert(dbSession, newCustomMetric("custom-key-1")
.setShortName("custom-name-1")
.setDescription("custom-description-1")
.setHidden(false));
dbSession.commit();
- WsTester.Result response = ws.newGetRequest(ENDPOINT, ACTION)
+ TestResponse response = tester.newRequest()
.setParam(MetricsAction.PARAM_PROJECT_ID, DEFAULT_PROJECT_UUID)
.execute();
}
@Test
- public void fail_if_project_id_nor_project_key_provided() throws Exception {
+ public void fail_if_project_id_nor_project_key_provided() {
expectedException.expect(IllegalArgumentException.class);
- ws.newGetRequest(ENDPOINT, ACTION).execute();
+ tester.newRequest().execute();
}
@Test
- public void fail_if_insufficient_privilege() throws Exception {
+ public void fail_if_insufficient_privilege() {
expectedException.expect(ForbiddenException.class);
userSession.logIn("login");
newRequest();
}
- private WsTester.Result newRequest() throws Exception {
- return ws.newGetRequest(ENDPOINT, ACTION)
+ private TestResponse newRequest() {
+ return tester.newRequest()
.setParam(MetricsAction.PARAM_PROJECT_ID, DEFAULT_PROJECT_UUID)
.execute();
}
import org.junit.Test;
import org.sonar.api.server.ws.WebService;
-import org.sonar.server.ws.WsTester;
import static org.assertj.core.api.Assertions.assertThat;
public class MeasuresWsTest {
- WsTester ws = new WsTester(
- new MeasuresWs(
- new ComponentAction(null, null, null)));
+ private MeasuresWs underTest = new MeasuresWs(new ComponentAction(null, null, null));
@Test
public void define_ws() {
- WebService.Controller controller = ws.controller("api/measures");
+ WebService.Context context = new WebService.Context();
+ underTest.define(context);
+
+ WebService.Controller controller = context.controller("api/measures");
assertThat(controller).isNotNull();
assertThat(controller.since()).isEqualTo("5.4");
}
*/
package org.sonar.server.measure.ws;
-import org.junit.Before;
import org.junit.Test;
import org.sonar.api.server.ws.WebService;
-import org.sonar.server.ws.WsTester;
import static org.assertj.core.api.Assertions.assertThat;
public class TimeMachineWsTest {
- WebService.Controller controller;
-
- @Before
- public void setUp() {
- WsTester tester = new WsTester(new TimeMachineWs());
- controller = tester.controller("api/timemachine");
- }
+ private TimeMachineWs underTest = new TimeMachineWs();
@Test
public void define_controller() {
+ WebService.Context context = new WebService.Context();
+
+ underTest.define(context);
+
+ WebService.Controller controller = context.controller("api/timemachine");
+
assertThat(controller).isNotNull();
assertThat(controller.since()).isEqualTo("2.10");
assertThat(controller.description()).isNotEmpty();
@Test
public void define_index_action() {
+ WebService.Context context = new WebService.Context();
+
+ underTest.define(context);
+
+ WebService.Controller controller = context.controller("api/timemachine");
WebService.Action action = controller.action("index");
assertThat(action).isNotNull();
assertThat(action.responseExampleAsString()).isNotEmpty();
import org.sonar.server.exceptions.ServerException;
import org.sonar.server.exceptions.UnauthorizedException;
import org.sonar.server.tester.UserSessionRule;
-import org.sonar.server.ws.WsTester;
+import org.sonar.server.ws.TestResponse;
+import org.sonar.server.ws.WsActionTester;
import static org.assertj.core.api.Assertions.assertThat;
import static org.sonar.server.metric.ws.CreateAction.PARAM_DESCRIPTION;
private DbClient dbClient = db.getDbClient();
private final DbSession dbSession = db.getSession();
- private WsTester ws;
+ private CreateAction underTest = new CreateAction(dbClient, userSessionRule);
+ private WsActionTester tester = new WsActionTester(underTest);
@Before
public void setUp() {
- ws = new WsTester(new MetricsWs(new CreateAction(dbClient, userSessionRule)));
userSessionRule.logIn().setSystemAdministrator();
}
@Test
- public void insert_new_minimalist_metric() throws Exception {
- newRequest()
+ public void insert_new_minimalist_metric() {
+ tester.newRequest()
.setParam(PARAM_KEY, DEFAULT_KEY)
.setParam(PARAM_NAME, DEFAULT_NAME)
.setParam(PARAM_TYPE, DEFAULT_TYPE)
}
@Test
- public void insert_new_full_metric() throws Exception {
- newRequest()
+ public void insert_new_full_metric() {
+ tester.newRequest()
.setParam(PARAM_KEY, DEFAULT_KEY)
.setParam(PARAM_NAME, DEFAULT_NAME)
.setParam(PARAM_TYPE, DEFAULT_TYPE)
}
@Test
- public void return_metric_with_id() throws Exception {
- WsTester.Result result = newRequest()
+ public void return_metric_with_id() {
+ TestResponse result = tester.newRequest()
.setParam(PARAM_KEY, DEFAULT_KEY)
.setParam(PARAM_NAME, DEFAULT_NAME)
.setParam(PARAM_TYPE, DEFAULT_TYPE)
.execute();
result.assertJson(getClass(), "metric.json");
- assertThat(result.outputAsString()).matches(".*\"id\"\\s*:\\s*\"\\w+\".*");
+ assertThat(result.getInput()).matches(".*\"id\"\\s*:\\s*\"\\w+\".*");
}
@Test
- public void update_existing_metric_when_custom_and_disabled() throws Exception {
+ public void update_existing_metric_when_custom_and_disabled() {
MetricDto metricInDb = MetricTesting.newMetricDto()
.setKey(DEFAULT_KEY)
.setValueType(ValueType.BOOL.name())
dbClient.metricDao().insert(dbSession, metricInDb);
dbSession.commit();
- WsTester.Result result = newRequest()
+ TestResponse result = tester.newRequest()
.setParam(PARAM_KEY, DEFAULT_KEY)
.setParam(PARAM_NAME, DEFAULT_NAME)
.setParam(PARAM_TYPE, DEFAULT_TYPE)
.execute();
result.assertJson(getClass(), "metric.json");
- result.outputAsString().matches("\"id\"\\s*:\\s*\"" + metricInDb.getId() + "\"");
+ result.getInput().matches("\"id\"\\s*:\\s*\"" + metricInDb.getId() + "\"");
MetricDto metricAfterWs = dbClient.metricDao().selectByKey(dbSession, DEFAULT_KEY);
assertThat(metricAfterWs.getId()).isEqualTo(metricInDb.getId());
assertThat(metricAfterWs.getDomain()).isEqualTo(DEFAULT_DOMAIN);
}
@Test
- public void fail_when_existing_activated_metric_with_same_key() throws Exception {
+ public void fail_when_existing_activated_metric_with_same_key() {
expectedException.expect(ServerException.class);
dbClient.metricDao().insert(dbSession, MetricTesting.newMetricDto()
.setKey(DEFAULT_KEY)
.setEnabled(true));
dbSession.commit();
- newRequest()
+ tester.newRequest()
.setParam(PARAM_KEY, DEFAULT_KEY)
.setParam(PARAM_NAME, "any-name")
.setParam(PARAM_TYPE, DEFAULT_TYPE).execute();
}
@Test
- public void fail_when_existing_non_custom_metric_with_same_key() throws Exception {
+ public void fail_when_existing_non_custom_metric_with_same_key() {
expectedException.expect(ServerException.class);
dbClient.metricDao().insert(dbSession, MetricTesting.newMetricDto()
.setKey(DEFAULT_KEY)
.setEnabled(false));
dbSession.commit();
- newRequest()
+ tester.newRequest()
.setParam(PARAM_KEY, DEFAULT_KEY)
.setParam(PARAM_NAME, "any-name")
.setParam(PARAM_TYPE, DEFAULT_TYPE).execute();
}
@Test
- public void fail_when_metric_type_is_changed_and_associated_measures_exist() throws Exception {
+ public void fail_when_metric_type_is_changed_and_associated_measures_exist() {
expectedException.expect(ServerException.class);
MetricDto metric = MetricTesting.newMetricDto()
.setKey(DEFAULT_KEY)
dbClient.customMeasureDao().insert(dbSession, CustomMeasureTesting.newCustomMeasureDto().setMetricId(metric.getId()));
dbSession.commit();
- newRequest()
+ tester.newRequest()
.setParam(PARAM_KEY, DEFAULT_KEY)
.setParam(PARAM_NAME, "any-name")
.setParam(PARAM_TYPE, ValueType.INT.name())
}
@Test
- public void fail_when_missing_key() throws Exception {
+ public void fail_when_missing_key() {
expectedException.expect(IllegalArgumentException.class);
- newRequest()
+ tester.newRequest()
.setParam(PARAM_NAME, DEFAULT_NAME)
.setParam(PARAM_TYPE, DEFAULT_TYPE).execute();
}
@Test
- public void fail_when_missing_name() throws Exception {
+ public void fail_when_missing_name() {
expectedException.expect(IllegalArgumentException.class);
- newRequest()
+ tester.newRequest()
.setParam(PARAM_KEY, DEFAULT_KEY)
.setParam(PARAM_TYPE, DEFAULT_TYPE).execute();
}
@Test
- public void fail_when_missing_type() throws Exception {
+ public void fail_when_missing_type() {
expectedException.expect(IllegalArgumentException.class);
- newRequest()
+ tester.newRequest()
.setParam(PARAM_NAME, DEFAULT_NAME)
.setParam(PARAM_KEY, DEFAULT_KEY).execute();
}
@Test
- public void throw_ForbiddenException_if_not_system_administrator() throws Exception {
+ public void throw_ForbiddenException_if_not_system_administrator() {
userSessionRule.logIn().setNonSystemAdministrator();
expectedException.expect(ForbiddenException.class);
expectedException.expectMessage("Insufficient privileges");
- newRequest()
+ tester.newRequest()
.setParam(PARAM_KEY, "any-key")
.setParam(PARAM_NAME, "any-name")
.setParam(PARAM_TYPE, DEFAULT_TYPE)
}
@Test
- public void throw_UnauthorizedException_if_not_logged_in() throws Exception {
+ public void throw_UnauthorizedException_if_not_logged_in() {
userSessionRule.anonymous();
expectedException.expect(UnauthorizedException.class);
expectedException.expectMessage("Authentication is required");
- newRequest()
+ tester.newRequest()
.setParam(PARAM_KEY, "any-key")
.setParam(PARAM_NAME, "any-name")
.setParam(PARAM_TYPE, DEFAULT_TYPE)
}
@Test
- public void fail_when_ill_formatted_key() throws Exception {
+ public void fail_when_ill_formatted_key() {
expectedException.expect(IllegalArgumentException.class);
expectedException.expectMessage("Malformed metric key '123:456'. Allowed characters are alphanumeric, '-', '_', with at least one non-digit.");
- newRequest()
+ tester.newRequest()
.setParam(PARAM_KEY, "123:456")
.setParam(PARAM_NAME, DEFAULT_NAME)
.setParam(PARAM_TYPE, DEFAULT_TYPE)
}
@Test
- public void fail_when_empty_name() throws Exception {
+ public void fail_when_empty_name() {
expectedException.expect(IllegalArgumentException.class);
- newRequest()
+ tester.newRequest()
.setParam(PARAM_KEY, DEFAULT_KEY)
.setParam(PARAM_NAME, "")
.setParam(PARAM_TYPE, DEFAULT_TYPE)
}
@Test
- public void fail_when_empty_type() throws Exception {
+ public void fail_when_empty_type() {
expectedException.expect(IllegalArgumentException.class);
- newRequest()
+ tester.newRequest()
.setParam(PARAM_KEY, DEFAULT_KEY)
.setParam(PARAM_NAME, DEFAULT_NAME)
.setParam(PARAM_TYPE, "")
.execute();
}
- private WsTester.TestRequest newRequest() {
- return ws.newPostRequest("api/metrics", "create");
- }
}
package org.sonar.server.metric.ws;
import org.junit.After;
-import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.utils.System2;
import org.sonar.db.TestDBSessions;
import org.sonar.db.metric.MetricDao;
import org.sonar.db.metric.MetricDto;
-import org.sonar.server.ws.WsTester;
+import org.sonar.server.ws.TestRequest;
+import org.sonar.server.ws.WsActionTester;
import org.sonar.test.JsonAssert;
import static org.sonar.db.metric.MetricTesting.newMetricDto;
@Rule
public DbTester db = DbTester.create(System2.INSTANCE);
- WsTester ws;
- DbClient dbClient;
- DbSession dbSession;
- @Before
- public void setUp() {
- dbClient = new DbClient(db.database(), db.myBatis(), new TestDBSessions(db.myBatis()), new MetricDao());
- dbSession = dbClient.openSession(false);
- ws = new WsTester(new MetricsWs(new DomainsAction(dbClient)));
- }
+ private DbClient dbClient = new DbClient(db.database(), db.myBatis(), new TestDBSessions(db.myBatis()), new MetricDao());
+ private DbSession dbSession = dbClient.openSession(false);
+ private DomainsAction underTest = new DomainsAction(dbClient);
+ private WsActionTester tester = new WsActionTester(underTest);
@After
public void tearDown() {
}
@Test
- public void json_example_validated() throws Exception {
+ public void json_example_validated() {
insertNewMetricDto(newEnabledMetric("API Compatibility"));
insertNewMetricDto(newEnabledMetric("Issues"));
insertNewMetricDto(newEnabledMetric("Rules"));
insertNewMetricDto(newEnabledMetric(""));
insertNewMetricDto(newMetricDto().setDomain("Domain of Deactivated Metric").setEnabled(false));
- WsTester.Result result = ws.newGetRequest(MetricsWs.ENDPOINT, "domains").execute();
+ TestRequest result = tester.newRequest();
- JsonAssert.assertJson(result.outputAsString()).isSimilarTo(getClass().getResource("example-domains.json"));
+ JsonAssert.assertJson(result.execute().getInput()).isSimilarTo(getClass().getResource("example-domains.json"));
}
private void insertNewMetricDto(MetricDto metric) {
*/
package org.sonar.server.metric.ws;
-import org.junit.Before;
import org.junit.Test;
import org.sonar.api.server.ws.WebService;
import org.sonar.db.DbClient;
import org.sonar.server.user.UserSession;
-import org.sonar.server.ws.WsTester;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
public class MetricsWsTest {
- WsTester ws;
-
- @Before
- public void setUp() {
- DbClient dbClient = mock(DbClient.class);
- UserSession userSession = mock(UserSession.class);
- ws = new WsTester(new MetricsWs(
+ private DbClient dbClient = mock(DbClient.class);
+ private UserSession userSession = mock(UserSession.class);
+ private MetricsWs underTest = new MetricsWs(
new SearchAction(dbClient),
new CreateAction(dbClient, userSession),
new UpdateAction(dbClient, userSession),
new DeleteAction(dbClient, userSession),
new TypesAction(),
- new DomainsAction(dbClient)));
- }
+ new DomainsAction(dbClient));
@Test
public void define_ws() {
- WebService.Controller controller = ws.controller("api/metrics");
+ WebService.Context context = new WebService.Context();
+
+ underTest.define(context);
+
+ WebService.Controller controller = context.controller("api/metrics");
assertThat(controller).isNotNull();
assertThat(controller.description()).isNotEmpty();
assertThat(controller.actions()).hasSize(6);
package org.sonar.server.metric.ws;
import org.apache.commons.lang.StringUtils;
-import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.server.ws.WebService.Param;
import org.sonar.db.DbSession;
import org.sonar.db.DbTester;
import org.sonar.db.metric.MetricDto;
-import org.sonar.server.ws.WsTester;
+import org.sonar.server.ws.TestResponse;
+import org.sonar.server.ws.WsActionTester;
import static org.assertj.core.api.Assertions.assertThat;
import static org.sonar.db.metric.MetricTesting.newMetricDto;
import static org.sonar.server.metric.ws.SearchAction.PARAM_IS_CUSTOM;
-
public class SearchActionTest {
@Rule
public DbTester db = DbTester.create(System2.INSTANCE);
- DbClient dbClient = db.getDbClient();
- final DbSession dbSession = db.getSession();
- WsTester ws;
- @Before
- public void setUp() {
- ws = new WsTester(new MetricsWs(new SearchAction(dbClient)));
- }
+ private DbClient dbClient = db.getDbClient();
+ private final DbSession dbSession = db.getSession();
+ private SearchAction underTest = new SearchAction(dbClient);
+ private WsActionTester tester = new WsActionTester(underTest);
@Test
- public void search_metrics_in_database() throws Exception {
+ public void search_metrics_in_database() {
insertNewCustomMetric("1", "2", "3");
- WsTester.Result result = newRequest().execute();
+ TestResponse result = tester.newRequest().execute();
result.assertJson(getClass(), "search_metrics.json");
}
@Test
- public void search_metrics_ordered_by_name_case_insensitive() throws Exception {
+ public void search_metrics_ordered_by_name_case_insensitive() {
insertNewCustomMetric("3", "1", "2");
- String firstResult = newRequest().setParam(Param.PAGE, "1").setParam(Param.PAGE_SIZE, "1").execute().outputAsString();
- String secondResult = newRequest().setParam(Param.PAGE, "2").setParam(Param.PAGE_SIZE, "1").execute().outputAsString();
- String thirdResult = newRequest().setParam(Param.PAGE, "3").setParam(Param.PAGE_SIZE, "1").execute().outputAsString();
+ String firstResult = tester.newRequest().setParam(Param.PAGE, "1").setParam(Param.PAGE_SIZE, "1").execute().getInput();
+ String secondResult = tester.newRequest().setParam(Param.PAGE, "2").setParam(Param.PAGE_SIZE, "1").execute().getInput();
+ String thirdResult = tester.newRequest().setParam(Param.PAGE, "3").setParam(Param.PAGE_SIZE, "1").execute().getInput();
assertThat(firstResult).contains("custom-key-1").doesNotContain("custom-key-2").doesNotContain("custom-key-3");
assertThat(secondResult).contains("custom-key-2").doesNotContain("custom-key-1").doesNotContain("custom-key-3");
}
@Test
- public void search_metrics_with_pagination() throws Exception {
+ public void search_metrics_with_pagination() {
insertNewCustomMetric("1", "2", "3", "4", "5", "6", "7", "8", "9", "10");
- WsTester.Result result = newRequest()
+ TestResponse result = tester.newRequest()
.setParam(Param.PAGE, "3")
.setParam(Param.PAGE_SIZE, "4")
.execute();
- assertThat(StringUtils.countMatches(result.outputAsString(), "custom-key")).isEqualTo(2);
+ assertThat(StringUtils.countMatches(result.getInput(), "custom-key")).isEqualTo(2);
}
@Test
- public void list_metric_with_is_custom_true() throws Exception {
+ public void list_metric_with_is_custom_true() {
insertNewCustomMetric("1", "2");
insertNewNonCustomMetric("3");
- String result = newRequest()
- .setParam(PARAM_IS_CUSTOM, "true").execute().outputAsString();
+ String result = tester.newRequest()
+ .setParam(PARAM_IS_CUSTOM, "true").execute().getInput();
assertThat(result).contains("custom-key-1", "custom-key-2")
.doesNotContain("non-custom-key-3");
}
@Test
- public void list_metric_with_is_custom_false() throws Exception {
+ public void list_metric_with_is_custom_false() {
insertNewCustomMetric("1", "2");
insertNewNonCustomMetric("3");
- String result = newRequest()
- .setParam(PARAM_IS_CUSTOM, "false").execute().outputAsString();
+ String result = tester.newRequest()
+ .setParam(PARAM_IS_CUSTOM, "false").execute().getInput();
assertThat(result).doesNotContain("custom-key-1")
.doesNotContain("custom-key-2")
}
@Test
- public void list_metric_with_chosen_fields() throws Exception {
+ public void list_metric_with_chosen_fields() {
insertNewCustomMetric("1");
- String result = newRequest().setParam(Param.FIELDS, "name").execute().outputAsString();
+ String result = tester.newRequest().setParam(Param.FIELDS, "name").execute().getInput();
assertThat(result).contains("id", "key", "name", "type")
.doesNotContain("domain")
.setEnabled(true);
}
- private WsTester.TestRequest newRequest() {
- return ws.newGetRequest("api/metrics", "search");
- }
}
*/
package org.sonar.server.metric.ws;
-import org.junit.Before;
import org.junit.Test;
import org.sonar.api.measures.Metric;
-import org.sonar.server.ws.WsTester;
+import org.sonar.server.ws.TestResponse;
+import org.sonar.server.ws.WsActionTester;
import static org.assertj.core.api.Assertions.assertThat;
public class TypesActionTest {
- WsTester ws;
-
- @Before
- public void setUp() {
- ws = new WsTester(new MetricsWs(new TypesAction()));
- }
+ private TypesAction underTest = new TypesAction();
+ private WsActionTester tester = new WsActionTester(underTest);
@Test
- public void validate_content() throws Exception {
- String response = ws.newGetRequest(MetricsWs.ENDPOINT, "types").execute().outputAsString();
+ public void validate_content() {
+ TestResponse response = tester.newRequest().execute();
- assertThat(response).contains(Metric.ValueType.names());
+ assertThat(response.getInput()).contains(Metric.ValueType.names());
}
}
import org.sonar.server.exceptions.ServerException;
import org.sonar.server.exceptions.UnauthorizedException;
import org.sonar.server.tester.UserSessionRule;
-import org.sonar.server.ws.WsTester;
+import org.sonar.server.ws.TestResponse;
+import org.sonar.server.ws.WsActionTester;
import static org.assertj.core.api.Assertions.assertThat;
import static org.sonar.db.measure.custom.CustomMeasureTesting.newCustomMeasureDto;
private DbClient dbClient = db.getDbClient();
private final DbSession dbSession = db.getSession();
- private WsTester ws;
+ private UpdateAction underTest = new UpdateAction(dbClient, userSessionRule);
+ private WsActionTester tester = new WsActionTester(underTest);
@Before
public void setUp() {
- ws = new WsTester(new MetricsWs(new UpdateAction(dbClient, userSessionRule)));
userSessionRule.logIn().setSystemAdministrator();
}
@Test
- public void update_all_fields() throws Exception {
+ public void update_all_fields() {
int id = insertMetric(newDefaultMetric());
- newRequest()
+ tester.newRequest()
.setParam(PARAM_ID, String.valueOf(id))
.setParam(PARAM_KEY, "another-key")
.setParam(PARAM_NAME, "another-name")
}
@Test
- public void update_one_field() throws Exception {
+ public void update_one_field() {
int id = insertMetric(newDefaultMetric());
dbClient.customMeasureDao().insert(dbSession, newCustomMeasureDto().setMetricId(id));
dbSession.commit();
- newRequest()
+ tester.newRequest()
.setParam(PARAM_ID, String.valueOf(id))
.setParam(PARAM_DESCRIPTION, "another-description")
.execute();
}
@Test
- public void update_return_the_full_object_with_id() throws Exception {
+ public void update_return_the_full_object_with_id() {
int id = insertMetric(newDefaultMetric().setDescription("another-description"));
- WsTester.Result requestResult = newRequest()
+ TestResponse requestResult = tester.newRequest()
.setParam(PARAM_ID, String.valueOf(id))
.setParam(PARAM_DESCRIPTION, DEFAULT_DESCRIPTION)
.execute();
dbSession.commit();
requestResult.assertJson(getClass(), "metric.json");
- assertThat(requestResult.outputAsString()).matches(".*\"id\"\\s*:\\s*\"" + id + "\".*");
+ assertThat(requestResult.getInput()).matches(".*\"id\"\\s*:\\s*\"" + id + "\".*");
}
@Test
- public void fail_when_changing_key_for_an_existing_one() throws Exception {
+ public void fail_when_changing_key_for_an_existing_one() {
expectedException.expect(ServerException.class);
expectedException.expectMessage("The key 'metric-key' is already used by an existing metric.");
insertMetric(newDefaultMetric().setKey("metric-key"));
int id = insertMetric(newDefaultMetric().setKey("another-key"));
- newRequest()
+ tester.newRequest()
.setParam(PARAM_ID, String.valueOf(id))
.setParam(PARAM_KEY, "metric-key")
.execute();
}
@Test
- public void fail_when_metric_not_in_db() throws Exception {
+ public void fail_when_metric_not_in_db() {
expectedException.expect(ServerException.class);
- newRequest().setParam(PARAM_ID, "42").execute();
+ tester.newRequest().setParam(PARAM_ID, "42").execute();
}
@Test
- public void fail_when_metric_is_deactivated() throws Exception {
+ public void fail_when_metric_is_deactivated() {
expectedException.expect(ServerException.class);
int id = insertMetric(newDefaultMetric().setEnabled(false));
- newRequest().setParam(PARAM_ID, String.valueOf(id)).execute();
+ tester.newRequest().setParam(PARAM_ID, String.valueOf(id)).execute();
}
@Test
- public void fail_when_metric_is_not_custom() throws Exception {
+ public void fail_when_metric_is_not_custom() {
expectedException.expect(ServerException.class);
int id = insertMetric(newDefaultMetric().setUserManaged(false));
- newRequest().setParam(PARAM_ID, String.valueOf(id)).execute();
+ tester.newRequest().setParam(PARAM_ID, String.valueOf(id)).execute();
}
@Test
- public void fail_when_custom_measures_and_type_changed() throws Exception {
+ public void fail_when_custom_measures_and_type_changed() {
expectedException.expect(ServerException.class);
int id = insertMetric(newDefaultMetric());
dbClient.customMeasureDao().insert(dbSession, newCustomMeasureDto().setMetricId(id));
dbSession.commit();
- newRequest()
+ tester.newRequest()
.setParam(PARAM_ID, String.valueOf(id))
.setParam(PARAM_TYPE, ValueType.BOOL.name())
.execute();
}
@Test
- public void fail_when_no_id() throws Exception {
+ public void fail_when_no_id() {
expectedException.expect(IllegalArgumentException.class);
- newRequest().execute();
+ tester.newRequest().execute();
}
@Test
- public void throw_ForbiddenException_if_not_system_administrator() throws Exception {
+ public void throw_ForbiddenException_if_not_system_administrator() {
userSessionRule.logIn().setNonSystemAdministrator();
expectedException.expect(ForbiddenException.class);
expectedException.expectMessage("Insufficient privileges");
- newRequest().execute();
+ tester.newRequest().execute();
}
@Test
- public void throw_UnauthorizedException_if_not_logged_in() throws Exception {
+ public void throw_UnauthorizedException_if_not_logged_in() {
userSessionRule.anonymous();
expectedException.expect(UnauthorizedException.class);
expectedException.expectMessage("Authentication is required");
- newRequest().execute();
+ tester.newRequest().execute();
}
@Test
- public void fail_when_metric_key_is_not_well_formatted() throws Exception {
+ public void fail_when_metric_key_is_not_well_formatted() {
int id = insertMetric(newDefaultMetric());
dbClient.customMeasureDao().insert(dbSession, newCustomMeasureDto().setMetricId(id));
dbSession.commit();
expectedException.expect(IllegalArgumentException.class);
expectedException.expectMessage("Malformed metric key 'not well formatted key'. Allowed characters are alphanumeric, '-', '_', with at least one non-digit.");
- newRequest()
+ tester.newRequest()
.setParam(PARAM_ID, String.valueOf(id))
.setParam(PARAM_KEY, "not well formatted key")
.execute();
return metricDto.getId();
}
- private WsTester.TestRequest newRequest() {
- return ws.newPostRequest("api/metrics", "update");
- }
}
import org.sonar.api.server.ws.Response;
import org.sonar.api.server.ws.WebService;
import org.sonar.api.server.ws.WebService.Controller;
-import org.sonar.server.ws.WsTester;
import static org.assertj.core.api.Assertions.assertThat;
public class NotificationsWsTest {
private NotificationsWsAction action = new FakeNotificationAction();
private NotificationsWsAction[] actions = {action};
- private WsTester ws = new WsTester(new NotificationsWs(actions));
-
- private Controller underTest = ws.controller("api/notifications");
+ private NotificationsWs underTest = new NotificationsWs(actions);
@Test
public void definition() {
- assertThat(underTest.path()).isEqualTo("api/notifications");
+ WebService.Context context = new WebService.Context();
+
+ underTest.define(context);
+
+ Controller controller = context.controller("api/notifications");
+ assertThat(controller.path()).isEqualTo("api/notifications");
}
private static class FakeNotificationAction implements NotificationsWsAction {
*/
package org.sonar.server.permission.ws;
-import org.junit.Rule;
import org.junit.Test;
-import org.sonar.api.resources.Qualifiers;
+import org.sonar.api.server.ws.Request;
+import org.sonar.api.server.ws.Response;
import org.sonar.api.server.ws.WebService;
-import org.sonar.db.DbTester;
-import org.sonar.db.component.ResourceTypesRule;
-import org.sonar.server.component.ComponentFinder;
-import org.sonar.server.issue.AvatarResolverImpl;
-import org.sonar.server.organization.TestDefaultOrganizationProvider;
-import org.sonar.server.permission.PermissionService;
-import org.sonar.server.permission.PermissionServiceImpl;
-import org.sonar.server.permission.RequestValidator;
-import org.sonar.server.permission.ws.template.TemplateGroupsAction;
-import org.sonar.server.permission.ws.template.TemplateUsersAction;
-import org.sonar.server.tester.UserSessionRule;
-import org.sonar.server.usergroups.DefaultGroupFinder;
-import org.sonar.server.usergroups.ws.GroupWsSupport;
-import org.sonar.server.ws.WsTester;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.sonarqube.ws.client.permission.PermissionsWsParameters.PARAM_PERMISSION;
public class PermissionsWsTest {
- @Rule
- public DbTester db = DbTester.create();
- @Rule
- public UserSessionRule userSession = UserSessionRule.standalone();
+ private PermissionsWs underTest = new PermissionsWs(new PermissionsWsAction() {
+ @Override
+ public void define(WebService.NewController context) {
+ context.createAction("foo").setHandler(this);
+ }
- private TestDefaultOrganizationProvider defaultOrganizationProvider = TestDefaultOrganizationProvider.from(db);
- private final ResourceTypesRule resourceTypes = new ResourceTypesRule().setRootQualifiers(Qualifiers.PROJECT);
- private final GroupWsSupport groupWsSupport = new GroupWsSupport(db.getDbClient(), defaultOrganizationProvider, new DefaultGroupFinder(db.getDbClient()));
- private final PermissionWsSupport wsSupport = new PermissionWsSupport(db.getDbClient(), new ComponentFinder(db.getDbClient(), resourceTypes), groupWsSupport);
+ @Override
+ public void handle(Request request, Response response) {
- private PermissionService permissionService = new PermissionServiceImpl(resourceTypes);
- private WsParameters wsParameters = new WsParameters(permissionService);
- private RequestValidator requestValidator = new RequestValidator(permissionService);
-
-
- private WsTester underTest = new WsTester(new PermissionsWs(
- new TemplateUsersAction(db.getDbClient(), userSession, wsSupport, new AvatarResolverImpl(), wsParameters, requestValidator),
- new TemplateGroupsAction(db.getDbClient(), userSession, wsSupport, wsParameters, requestValidator)));
+ }
+ });
@Test
public void define_controller() {
- WebService.Controller controller = controller();
+ WebService.Context context = new WebService.Context();
+
+ underTest.define(context);
+
+ WebService.Controller controller = context.controller("api/permissions");
assertThat(controller).isNotNull();
assertThat(controller.description()).isNotEmpty();
assertThat(controller.since()).isEqualTo("3.7");
- assertThat(controller.actions()).hasSize(2);
+ assertThat(controller.actions()).hasSize(1);
}
- @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 define_template_groups() {
- WebService.Action action = controller().action("template_groups");
-
- assertThat(action).isNotNull();
- assertThat(action.isPost()).isFalse();
- assertThat(action.isInternal()).isTrue();
- assertThat(action.since()).isEqualTo("5.2");
- }
-
- private WebService.Controller controller() {
- return underTest.controller("api/permissions");
- }
}
import org.junit.Test;
import org.sonar.api.resources.Qualifiers;
import org.sonar.api.resources.ResourceTypes;
+import org.sonar.api.server.ws.WebService;
import org.sonar.core.permission.GlobalPermissions;
import org.sonar.db.component.ResourceTypesRule;
import org.sonar.db.organization.OrganizationDto;
return new TemplateGroupsAction(db.getDbClient(), userSession, newPermissionWsSupport(), wsParameters, requestValidator);
}
+ @Test
+ public void define_template_groups() {
+ WebService.Action action = wsTester.getDef();
+
+ assertThat(action).isNotNull();
+ assertThat(action.key()).isEqualTo("template_groups");
+ assertThat(action.isPost()).isFalse();
+ assertThat(action.isInternal()).isTrue();
+ assertThat(action.since()).isEqualTo("5.2");
+ }
+
@Test
public void template_groups_of_json_example() {
GroupDto adminGroup = insertGroupOnDefaultOrganization("sonar-administrators", "System administrators");
return new TemplateUsersAction(db.getDbClient(), userSession, newPermissionWsSupport(), new AvatarResolverImpl(), wsParameters, requestValidator);
}
+ @Test
+ public void define_template_users() {
+ WebService.Action action = wsTester.getDef();
+
+ assertThat(action).isNotNull();
+ assertThat(action.key()).isEqualTo("template_users");
+ assertThat(action.isPost()).isFalse();
+ assertThat(action.isInternal()).isTrue();
+ assertThat(action.since()).isEqualTo("5.2");
+ assertThat(action.param(PARAM_PERMISSION).isRequired()).isFalse();
+ }
+
@Test
public void search_for_users_with_response_example() {
UserDto user1 = insertUser(newUserDto().setLogin("admin").setName("Administrator").setEmail("admin@admin.com"));
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
-import org.sonar.api.server.ws.Request;
import org.sonar.api.utils.DateUtils;
import org.sonar.db.Database;
import org.sonar.db.dialect.Dialect;
+import org.sonar.server.platform.db.migration.DatabaseMigrationState;
import org.sonar.server.platform.db.migration.DatabaseMigrationState.Status;
import org.sonar.server.platform.db.migration.version.DatabaseVersion;
-import org.sonar.server.platform.db.migration.DatabaseMigrationState;
-import org.sonar.server.ws.WsTester;
+import org.sonar.server.ws.TestResponse;
+import org.sonar.server.ws.WsActionTester;
import static com.google.common.base.Predicates.in;
import static com.google.common.base.Predicates.not;
private Dialect dialect = mock(Dialect.class);
private DatabaseMigrationState migrationState = mock(DatabaseMigrationState.class);
private DbMigrationStatusAction underTest = new DbMigrationStatusAction(databaseVersion, database, migrationState);
-
- private Request request = mock(Request.class);
- private WsTester.TestResponse response = new WsTester.TestResponse();
+ private WsActionTester tester = new WsActionTester(underTest);
@Before
public void wireMocksTogether() {
}
@Test
- public void verify_example() throws Exception {
+ public void verify_example() {
when(dialect.supportsMigration()).thenReturn(true);
when(migrationState.getStatus()).thenReturn(RUNNING);
when(migrationState.getStartedAt()).thenReturn(DateUtils.parseDateTime("2015-02-23T18:54:23+0100"));
- underTest.handle(request, response);
- assertJson(response.outputAsString()).isSimilarTo(getClass().getResource("example-migrate_db.json"));
+ TestResponse response = tester.newRequest().execute();
+
+ assertJson(response.getInput()).isSimilarTo(getClass().getResource("example-migrate_db.json"));
}
@Test
- public void throws_ISE_when_database_has_no_version() throws Exception {
+ public void throws_ISE_when_database_has_no_version() {
reset(database);
when(databaseVersion.getVersion()).thenReturn(Optional.empty());
expectedException.expect(IllegalStateException.class);
expectedException.expectMessage("Cannot connect to Database.");
- underTest.handle(request, response);
+ tester.newRequest().execute();
}
@Test
- public void msg_is_operational_and_state_from_databasemigration_when_databaseversion_status_is_UP_TO_DATE() throws Exception {
+ public void msg_is_operational_and_state_from_databasemigration_when_databaseversion_status_is_UP_TO_DATE() {
when(databaseVersion.getStatus()).thenReturn(DatabaseVersion.Status.UP_TO_DATE);
when(migrationState.getStatus()).thenReturn(NONE);
- underTest.handle(request, response);
+ TestResponse response = tester.newRequest().execute();
- assertJson(response.outputAsString()).isSimilarTo(expectedResponse(STATUS_NO_MIGRATION, MESSAGE_STATUS_NONE));
+ assertJson(response.getInput()).isSimilarTo(expectedResponse(STATUS_NO_MIGRATION, MESSAGE_STATUS_NONE));
}
// this test will raise a IllegalArgumentException when an unsupported value is added to the Status enum
@Test
@UseDataProvider("statusRequiringDbMigration")
- public void defensive_test_all_values_of_Status_must_be_supported(DatabaseVersion.Status status) throws Exception {
+ public void defensive_test_all_values_of_Status_must_be_supported(DatabaseVersion.Status status) {
when(databaseVersion.getStatus()).thenReturn(status);
for (Status migrationStatus : filter(Arrays.asList(DatabaseMigrationState.Status.values()), not(in(ImmutableList.of(NONE, RUNNING, FAILED, SUCCEEDED))))) {
when(migrationState.getStatus()).thenReturn(migrationStatus);
- underTest.handle(request, response);
+ tester.newRequest().execute();
}
}
@Test
- public void state_from_databasemigration_when_databaseversion_status_is_REQUIRES_DOWNGRADE() throws Exception {
+ public void state_from_databasemigration_when_databaseversion_status_is_REQUIRES_DOWNGRADE() {
when(databaseVersion.getStatus()).thenReturn(DatabaseVersion.Status.REQUIRES_DOWNGRADE);
when(migrationState.getStatus()).thenReturn(NONE);
- underTest.handle(request, response);
+ TestResponse response = tester.newRequest().execute();
- assertJson(response.outputAsString()).isSimilarTo(expectedResponse(STATUS_NO_MIGRATION, MESSAGE_STATUS_NONE));
+ assertJson(response.getInput()).isSimilarTo(expectedResponse(STATUS_NO_MIGRATION, MESSAGE_STATUS_NONE));
}
@Test
@UseDataProvider("statusRequiringDbMigration")
- public void state_is_NONE_with_specific_msg_when_db_requires_upgrade_but_dialect_does_not_support_migration(DatabaseVersion.Status status) throws Exception {
+ public void state_is_NONE_with_specific_msg_when_db_requires_upgrade_but_dialect_does_not_support_migration(DatabaseVersion.Status status) {
when(databaseVersion.getStatus()).thenReturn(status);
when(dialect.supportsMigration()).thenReturn(false);
- underTest.handle(request, response);
+ TestResponse response = tester.newRequest().execute();
- assertJson(response.outputAsString()).isSimilarTo(expectedResponse(STATUS_NOT_SUPPORTED, MESSAGE_NO_MIGRATION_ON_EMBEDDED_DATABASE));
+ assertJson(response.getInput()).isSimilarTo(expectedResponse(STATUS_NOT_SUPPORTED, MESSAGE_NO_MIGRATION_ON_EMBEDDED_DATABASE));
}
@Test
@UseDataProvider("statusRequiringDbMigration")
- public void state_from_database_migration_when_dbmigration_status_is_RUNNING(DatabaseVersion.Status status) throws Exception {
+ public void state_from_database_migration_when_dbmigration_status_is_RUNNING(DatabaseVersion.Status status) {
when(databaseVersion.getStatus()).thenReturn(status);
when(dialect.supportsMigration()).thenReturn(true);
when(migrationState.getStatus()).thenReturn(RUNNING);
when(migrationState.getStartedAt()).thenReturn(SOME_DATE);
- underTest.handle(request, response);
+ TestResponse response = tester.newRequest().execute();
- assertJson(response.outputAsString()).isSimilarTo(expectedResponse(STATUS_MIGRATION_RUNNING, MESSAGE_STATUS_RUNNING, SOME_DATE));
+ assertJson(response.getInput()).isSimilarTo(expectedResponse(STATUS_MIGRATION_RUNNING, MESSAGE_STATUS_RUNNING, SOME_DATE));
}
@Test
@UseDataProvider("statusRequiringDbMigration")
- public void state_from_database_migration_and_msg_includes_error_when_dbmigration_status_is_FAILED(DatabaseVersion.Status status) throws Exception {
+ public void state_from_database_migration_and_msg_includes_error_when_dbmigration_status_is_FAILED(DatabaseVersion.Status status) {
when(databaseVersion.getStatus()).thenReturn(status);
when(dialect.supportsMigration()).thenReturn(true);
when(migrationState.getStatus()).thenReturn(FAILED);
when(migrationState.getStartedAt()).thenReturn(SOME_DATE);
when(migrationState.getError()).thenReturn(new UnsupportedOperationException(SOME_THROWABLE_MSG));
- underTest.handle(request, response);
+ TestResponse response = tester.newRequest().execute();
- assertJson(response.outputAsString()).isSimilarTo(expectedResponse(STATUS_MIGRATION_FAILED, failedMsg(SOME_THROWABLE_MSG), SOME_DATE));
+ assertJson(response.getInput()).isSimilarTo(expectedResponse(STATUS_MIGRATION_FAILED, failedMsg(SOME_THROWABLE_MSG), SOME_DATE));
}
@Test
@UseDataProvider("statusRequiringDbMigration")
- public void state_from_database_migration_and_msg_has_default_msg_when_dbmigration_status_is_FAILED(DatabaseVersion.Status status) throws Exception {
+ public void state_from_database_migration_and_msg_has_default_msg_when_dbmigration_status_is_FAILED(DatabaseVersion.Status status) {
when(databaseVersion.getStatus()).thenReturn(status);
when(dialect.supportsMigration()).thenReturn(true);
when(migrationState.getStatus()).thenReturn(FAILED);
when(migrationState.getStartedAt()).thenReturn(SOME_DATE);
when(migrationState.getError()).thenReturn(null); // no failure throwable caught
- underTest.handle(request, response);
+ TestResponse response = tester.newRequest().execute();
- assertJson(response.outputAsString()).isSimilarTo(expectedResponse(STATUS_MIGRATION_FAILED, failedMsg(DEFAULT_ERROR_MSG), SOME_DATE));
+ assertJson(response.getInput()).isSimilarTo(expectedResponse(STATUS_MIGRATION_FAILED, failedMsg(DEFAULT_ERROR_MSG), SOME_DATE));
}
@Test
@UseDataProvider("statusRequiringDbMigration")
- public void state_from_database_migration_and_msg_has_default_msg_when_dbmigration_status_is_SUCCEEDED(DatabaseVersion.Status status) throws Exception {
+ public void state_from_database_migration_and_msg_has_default_msg_when_dbmigration_status_is_SUCCEEDED(DatabaseVersion.Status status) {
when(databaseVersion.getStatus()).thenReturn(status);
when(dialect.supportsMigration()).thenReturn(true);
when(migrationState.getStatus()).thenReturn(SUCCEEDED);
when(migrationState.getStartedAt()).thenReturn(SOME_DATE);
- underTest.handle(request, response);
+ TestResponse response = tester.newRequest().execute();
- assertJson(response.outputAsString()).isSimilarTo(expectedResponse(STATUS_MIGRATION_SUCCEEDED, MESSAGE_STATUS_SUCCEEDED, SOME_DATE));
+ assertJson(response.getInput()).isSimilarTo(expectedResponse(STATUS_MIGRATION_SUCCEEDED, MESSAGE_STATUS_SUCCEEDED, SOME_DATE));
}
@Test
@UseDataProvider("statusRequiringDbMigration")
- public void start_migration_and_return_state_from_databasemigration_when_dbmigration_status_is_NONE(DatabaseVersion.Status status) throws Exception {
+ public void start_migration_and_return_state_from_databasemigration_when_dbmigration_status_is_NONE(DatabaseVersion.Status status) {
when(databaseVersion.getStatus()).thenReturn(status);
when(dialect.supportsMigration()).thenReturn(true);
when(migrationState.getStatus()).thenReturn(NONE);
when(migrationState.getStartedAt()).thenReturn(SOME_DATE);
- underTest.handle(request, response);
+ TestResponse response = tester.newRequest().execute();
- assertJson(response.outputAsString()).isSimilarTo(expectedResponse(STATUS_MIGRATION_REQUIRED, MESSAGE_MIGRATION_REQUIRED));
+ assertJson(response.getInput()).isSimilarTo(expectedResponse(STATUS_MIGRATION_REQUIRED, MESSAGE_MIGRATION_REQUIRED));
}
@DataProvider
public static Object[][] statusRequiringDbMigration() {
return new Object[][] {
- { DatabaseVersion.Status.FRESH_INSTALL },
- { DatabaseVersion.Status.REQUIRES_UPGRADE },
+ {DatabaseVersion.Status.FRESH_INSTALL},
+ {DatabaseVersion.Status.REQUIRES_UPGRADE},
};
}
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
-import org.sonar.api.server.ws.Request;
import org.sonar.api.utils.DateUtils;
import org.sonar.db.Database;
import org.sonar.db.dialect.Dialect;
import org.sonar.server.platform.db.migration.DatabaseMigration;
+import org.sonar.server.platform.db.migration.DatabaseMigrationState;
import org.sonar.server.platform.db.migration.DatabaseMigrationState.Status;
import org.sonar.server.platform.db.migration.version.DatabaseVersion;
-import org.sonar.server.platform.db.migration.DatabaseMigrationState;
-import org.sonar.server.ws.WsTester;
+import org.sonar.server.ws.TestResponse;
+import org.sonar.server.ws.WsActionTester;
import static com.google.common.base.Predicates.in;
import static com.google.common.base.Predicates.not;
private DatabaseMigration databaseMigration = mock(DatabaseMigration.class);
private DatabaseMigrationState migrationState = mock(DatabaseMigrationState.class);
private MigrateDbAction underTest = new MigrateDbAction(databaseVersion, database, migrationState, databaseMigration);
-
- private Request request = mock(Request.class);
- private WsTester.TestResponse response = new WsTester.TestResponse();
+ private WsActionTester tester = new WsActionTester(underTest);
@Before
public void wireMocksTogether() {
}
@Test
- public void ISE_is_thrown_when_version_can_not_be_retrieved_from_database() throws Exception {
+ public void ISE_is_thrown_when_version_can_not_be_retrieved_from_database() {
reset(databaseVersion);
when(databaseVersion.getVersion()).thenReturn(Optional.empty());
expectedException.expect(IllegalStateException.class);
expectedException.expectMessage("Cannot connect to Database.");
- underTest.handle(request, response);
+ tester.newRequest().execute();
}
@Test
- public void verify_example() throws Exception {
+ public void verify_example() {
when(dialect.supportsMigration()).thenReturn(true);
when(migrationState.getStatus()).thenReturn(RUNNING);
when(migrationState.getStartedAt()).thenReturn(DateUtils.parseDateTime("2015-02-23T18:54:23+0100"));
- underTest.handle(request, response);
- assertJson(response.outputAsString()).isSimilarTo(getClass().getResource("example-migrate_db.json"));
+ TestResponse response = tester.newRequest().execute();
+
+ assertJson(response.getInput()).isSimilarTo(getClass().getResource("example-migrate_db.json"));
}
@Test
- public void msg_is_operational_and_state_from_database_migration_when_databaseversion_status_is_UP_TO_DATE() throws Exception {
+ public void msg_is_operational_and_state_from_database_migration_when_databaseversion_status_is_UP_TO_DATE() {
when(databaseVersion.getStatus()).thenReturn(DatabaseVersion.Status.UP_TO_DATE);
when(migrationState.getStatus()).thenReturn(NONE);
- underTest.handle(request, response);
+ TestResponse response = tester.newRequest().execute();
- assertJson(response.outputAsString()).isSimilarTo(expectedResponse(STATUS_NO_MIGRATION, MESSAGE_STATUS_NONE));
+ assertJson(response.getInput()).isSimilarTo(expectedResponse(STATUS_NO_MIGRATION, MESSAGE_STATUS_NONE));
}
// this test will raise a IllegalArgumentException when an unsupported value is added to the Status enum
@Test
- public void defensive_test_all_values_of_migration_Status_must_be_supported() throws Exception {
+ public void defensive_test_all_values_of_migration_Status_must_be_supported() {
for (Status status : filter(Arrays.asList(DatabaseMigrationState.Status.values()), not(in(ImmutableList.of(NONE, RUNNING, FAILED, SUCCEEDED))))) {
when(migrationState.getStatus()).thenReturn(status);
- underTest.handle(request, response);
+ tester.newRequest().execute();
}
}
@Test
- public void state_from_database_migration_when_databaseversion_status_is_REQUIRES_DOWNGRADE() throws Exception {
+ public void state_from_database_migration_when_databaseversion_status_is_REQUIRES_DOWNGRADE() {
when(databaseVersion.getStatus()).thenReturn(DatabaseVersion.Status.REQUIRES_DOWNGRADE);
when(migrationState.getStatus()).thenReturn(NONE);
- underTest.handle(request, response);
+ TestResponse response = tester.newRequest().execute();
- assertJson(response.outputAsString()).isSimilarTo(expectedResponse(STATUS_NO_MIGRATION, MESSAGE_STATUS_NONE));
+ assertJson(response.getInput()).isSimilarTo(expectedResponse(STATUS_NO_MIGRATION, MESSAGE_STATUS_NONE));
}
@Test
@UseDataProvider("statusRequiringDbMigration")
- public void state_is_NONE_with_specific_msg_when_db_requires_upgrade_but_dialect_does_not_support_migration(DatabaseVersion.Status status) throws Exception {
+ public void state_is_NONE_with_specific_msg_when_db_requires_upgrade_but_dialect_does_not_support_migration(DatabaseVersion.Status status) {
when(databaseVersion.getStatus()).thenReturn(status);
when(dialect.supportsMigration()).thenReturn(false);
- underTest.handle(request, response);
+ TestResponse response = tester.newRequest().execute();
- assertJson(response.outputAsString()).isSimilarTo(expectedResponse(STATUS_NOT_SUPPORTED, MESSAGE_NO_MIGRATION_ON_EMBEDDED_DATABASE));
+ assertJson(response.getInput()).isSimilarTo(expectedResponse(STATUS_NOT_SUPPORTED, MESSAGE_NO_MIGRATION_ON_EMBEDDED_DATABASE));
}
@Test
@UseDataProvider("statusRequiringDbMigration")
- public void state_from_database_migration_when_dbmigration_status_is_RUNNING(DatabaseVersion.Status status) throws Exception {
+ public void state_from_database_migration_when_dbmigration_status_is_RUNNING(DatabaseVersion.Status status) {
when(databaseVersion.getStatus()).thenReturn(status);
when(dialect.supportsMigration()).thenReturn(true);
when(migrationState.getStatus()).thenReturn(RUNNING);
when(migrationState.getStartedAt()).thenReturn(SOME_DATE);
- underTest.handle(request, response);
+ TestResponse response = tester.newRequest().execute();
- assertJson(response.outputAsString()).isSimilarTo(expectedResponse(STATUS_MIGRATION_RUNNING, MESSAGE_STATUS_RUNNING, SOME_DATE));
+ assertJson(response.getInput()).isSimilarTo(expectedResponse(STATUS_MIGRATION_RUNNING, MESSAGE_STATUS_RUNNING, SOME_DATE));
}
@Test
@UseDataProvider("statusRequiringDbMigration")
- public void state_from_database_migration_and_msg_includes_error_when_dbmigration_status_is_FAILED(DatabaseVersion.Status status) throws Exception {
+ public void state_from_database_migration_and_msg_includes_error_when_dbmigration_status_is_FAILED(DatabaseVersion.Status status) {
when(databaseVersion.getStatus()).thenReturn(status);
when(dialect.supportsMigration()).thenReturn(true);
when(migrationState.getStatus()).thenReturn(FAILED);
when(migrationState.getStartedAt()).thenReturn(SOME_DATE);
when(migrationState.getError()).thenReturn(new UnsupportedOperationException(SOME_THROWABLE_MSG));
- underTest.handle(request, response);
+ TestResponse response = tester.newRequest().execute();
- assertJson(response.outputAsString()).isSimilarTo(expectedResponse(STATUS_MIGRATION_FAILED, failedMsg(SOME_THROWABLE_MSG), SOME_DATE));
+ assertJson(response.getInput()).isSimilarTo(expectedResponse(STATUS_MIGRATION_FAILED, failedMsg(SOME_THROWABLE_MSG), SOME_DATE));
}
@Test
@UseDataProvider("statusRequiringDbMigration")
- public void state_from_database_migration_and_msg_has_default_msg_when_dbmigration_status_is_FAILED(DatabaseVersion.Status status) throws Exception {
+ public void state_from_database_migration_and_msg_has_default_msg_when_dbmigration_status_is_FAILED(DatabaseVersion.Status status) {
when(databaseVersion.getStatus()).thenReturn(status);
when(dialect.supportsMigration()).thenReturn(true);
when(migrationState.getStatus()).thenReturn(FAILED);
when(migrationState.getStartedAt()).thenReturn(SOME_DATE);
when(migrationState.getError()).thenReturn(null); // no failure throwable caught
- underTest.handle(request, response);
+ TestResponse response = tester.newRequest().execute();
- assertJson(response.outputAsString()).isSimilarTo(expectedResponse(STATUS_MIGRATION_FAILED, failedMsg(DEFAULT_ERROR_MSG), SOME_DATE));
+ assertJson(response.getInput()).isSimilarTo(expectedResponse(STATUS_MIGRATION_FAILED, failedMsg(DEFAULT_ERROR_MSG), SOME_DATE));
}
@Test
@UseDataProvider("statusRequiringDbMigration")
- public void state_from_database_migration_and_msg_has_default_msg_when_dbmigration_status_is_SUCCEEDED(DatabaseVersion.Status status) throws Exception {
+ public void state_from_database_migration_and_msg_has_default_msg_when_dbmigration_status_is_SUCCEEDED(DatabaseVersion.Status status) {
when(databaseVersion.getStatus()).thenReturn(status);
when(dialect.supportsMigration()).thenReturn(true);
when(migrationState.getStatus()).thenReturn(SUCCEEDED);
when(migrationState.getStartedAt()).thenReturn(SOME_DATE);
- underTest.handle(request, response);
+ TestResponse response = tester.newRequest().execute();
- assertJson(response.outputAsString()).isSimilarTo(expectedResponse(STATUS_MIGRATION_SUCCEEDED, MESSAGE_STATUS_SUCCEEDED, SOME_DATE));
+ assertJson(response.getInput()).isSimilarTo(expectedResponse(STATUS_MIGRATION_SUCCEEDED, MESSAGE_STATUS_SUCCEEDED, SOME_DATE));
}
@Test
@UseDataProvider("statusRequiringDbMigration")
- public void start_migration_and_return_state_from_databasemigration_when_dbmigration_status_is_NONE(DatabaseVersion.Status status) throws Exception {
+ public void start_migration_and_return_state_from_databasemigration_when_dbmigration_status_is_NONE(DatabaseVersion.Status status) {
when(databaseVersion.getStatus()).thenReturn(status);
when(dialect.supportsMigration()).thenReturn(true);
when(migrationState.getStatus()).thenReturn(NONE);
when(migrationState.getStartedAt()).thenReturn(SOME_DATE);
- underTest.handle(request, response);
+ TestResponse response = tester.newRequest().execute();
verify(databaseMigration).startIt();
- assertJson(response.outputAsString()).isSimilarTo(expectedResponse(STATUS_MIGRATION_RUNNING, MESSAGE_STATUS_RUNNING, SOME_DATE));
+ assertJson(response.getInput()).isSimilarTo(expectedResponse(STATUS_MIGRATION_RUNNING, MESSAGE_STATUS_RUNNING, SOME_DATE));
}
@DataProvider
public static Object[][] statusRequiringDbMigration() {
return new Object[][] {
- { DatabaseVersion.Status.FRESH_INSTALL },
- { DatabaseVersion.Status.REQUIRES_UPGRADE },
+ {DatabaseVersion.Status.FRESH_INSTALL},
+ {DatabaseVersion.Status.REQUIRES_UPGRADE},
};
}
import org.junit.Test;
import org.sonar.api.platform.Server;
+import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.WebService;
-import org.sonar.server.ws.WsTester;
+import org.sonar.server.ws.DumbResponse;
+import org.sonar.server.ws.TestResponse;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
public class ServerWsTest {
private Server server = mock(Server.class);
- private WsTester tester = new WsTester(new ServerWs(server));
+ private ServerWs underTest = new ServerWs(server);
@Test
public void define_version_action() {
- WebService.Controller controller = tester.controller("api/server");
+ WebService.Context context = new WebService.Context();
+
+ underTest.define(context);
+
+ WebService.Controller controller = context.controller("api/server");
assertThat(controller.actions()).hasSize(1);
WebService.Action versionAction = controller.action("version");
@Test
public void returns_version_as_plain_text() throws Exception {
when(server.getVersion()).thenReturn("6.4-SNAPSHOT");
- WsTester.Result result = tester.newGetRequest("api/server", "version").execute();
- assertThat(result.outputAsString()).isEqualTo("6.4-SNAPSHOT");
+
+ DumbResponse response = new DumbResponse();
+ underTest.handle(mock(Request.class), response);
+
+ assertThat(new TestResponse(response).getInput()).isEqualTo("6.4-SNAPSHOT");
}
@Test
public void test_example_of_version() {
- WebService.Action versionAction = tester.action("api/server", "version");
- assertThat(versionAction.responseExampleAsString()).isEqualTo("6.3.0.1234");
+ WebService.Context context = new WebService.Context();
+ underTest.define(context);
+
+ WebService.Action action = context.controller("api/server").action("version");
+ assertThat(action).isNotNull();
+ assertThat(action.responseExampleAsString()).isEqualTo("6.3.0.1234");
}
}
import com.google.common.base.Optional;
import org.junit.Before;
import org.junit.Test;
-import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.WebService;
import org.sonar.api.utils.DateUtils;
import org.sonar.server.plugins.UpdateCenterMatrixFactory;
+import org.sonar.server.ws.TestResponse;
import org.sonar.server.ws.WsActionTester;
-import org.sonar.server.ws.WsTester;
import org.sonar.updatecenter.common.Plugin;
import org.sonar.updatecenter.common.Release;
import org.sonar.updatecenter.common.Sonar;
import static org.sonar.test.JsonAssert.assertJson;
public class UpgradesActionTest {
- private static final String DUMMY_CONTROLLER_KEY = "dummy";
private static final String JSON_EMPTY_UPGRADE_LIST = "{" +
" \"upgrades\":" + "[]" +
"}";
private UpdateCenter updateCenter = mock(UpdateCenter.class);
private UpgradesAction underTest = new UpgradesAction(updateCenterFactory);
- private Request request = mock(Request.class);
- private WsTester.TestResponse response = new WsTester.TestResponse();
+ private WsActionTester tester = new WsActionTester(underTest);
private static SonarUpdate createSonar_51_update() {
Plugin brandingPlugin = Plugin.factory("branding")
@Test
public void action_updates_is_defined() {
- WsTester wsTester = new WsTester();
- WebService.NewController newController = wsTester.context().createController(DUMMY_CONTROLLER_KEY);
+ WebService.Action def = tester.getDef();
- underTest.define(newController);
- newController.done();
+ assertThat(def.key()).isEqualTo("upgrades");
+ assertThat(def.isPost()).isFalse();
+ assertThat(def.description()).isNotEmpty();
+ assertThat(def.responseExample()).isNotNull();
- 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();
+ assertThat(def.params()).isEmpty();
}
@Test
- public void empty_array_is_returned_when_there_is_no_upgrade_available() throws Exception {
- underTest.handle(request, response);
+ public void empty_array_is_returned_when_there_is_no_upgrade_available() {
+ TestResponse response = tester.newRequest().execute();
- assertJson(response.outputAsString()).withStrictArrayOrder().isSimilarTo(JSON_EMPTY_UPGRADE_LIST);
+ assertJson(response.getInput()).withStrictArrayOrder().isSimilarTo(JSON_EMPTY_UPGRADE_LIST);
}
@Test
- public void empty_array_is_returned_when_update_center_is_unavailable() throws Exception {
+ public void empty_array_is_returned_when_update_center_is_unavailable() {
when(updateCenterFactory.getUpdateCenter(anyBoolean())).thenReturn(Optional.absent());
- underTest.handle(request, response);
+ TestResponse response = tester.newRequest().execute();
- assertJson(response.outputAsString()).withStrictArrayOrder().isSimilarTo(JSON_EMPTY_UPGRADE_LIST);
+ assertJson(response.getInput()).withStrictArrayOrder().isSimilarTo(JSON_EMPTY_UPGRADE_LIST);
}
@Test
- public void verify_JSON_response_against_example() throws Exception {
+ public void verify_JSON_response_against_example() {
SonarUpdate sonarUpdate = createSonar_51_update();
when(updateCenter.findSonarUpdates()).thenReturn(of(sonarUpdate));
- underTest.handle(request, response);
+ TestResponse response = tester.newRequest().execute();
- assertJson(response.outputAsString()).withStrictArrayOrder()
- .isSimilarTo(new WsActionTester(underTest).getDef().responseExampleAsString());
+ assertJson(response.getInput()).withStrictArrayOrder()
+ .isSimilarTo(tester.getDef().responseExampleAsString());
}
}
package org.sonar.server.plugins.ws;
import com.google.common.base.Optional;
-import java.net.URL;
import org.junit.Before;
-import org.sonar.api.server.ws.Request;
import org.sonar.api.utils.DateUtils;
import org.sonar.server.plugins.UpdateCenterMatrixFactory;
-import org.sonar.server.ws.WsTester;
import org.sonar.updatecenter.common.Plugin;
import org.sonar.updatecenter.common.PluginUpdate;
import org.sonar.updatecenter.common.Release;
protected UpdateCenterMatrixFactory updateCenterFactory = mock(UpdateCenterMatrixFactory.class);
protected UpdateCenter updateCenter = mock(UpdateCenter.class);
- protected Request request = mock(Request.class);
- protected WsTester.TestResponse response = new WsTester.TestResponse();
protected static Release release(Plugin plugin1, String version) {
return new Release(plugin1, create(version));
return PluginUpdate.createWithStatus(pluginRelease, compatible);
}
- protected static URL resource(String s) {
- Class<AvailableActionTest> clazz = AvailableActionTest.class;
- return clazz.getResource(clazz.getSimpleName() + "/" + s);
- }
-
protected static PluginUpdate pluginUpdate(String key, String name) {
return PluginUpdate.createWithStatus(
new Release(Plugin.factory(key).setName(name), Version.create("1.0")),
import org.sonar.api.utils.DateUtils;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.tester.UserSessionRule;
+import org.sonar.server.ws.TestResponse;
import org.sonar.server.ws.WsActionTester;
-import org.sonar.server.ws.WsTester;
import org.sonar.updatecenter.common.Plugin;
import org.sonar.updatecenter.common.PluginUpdate;
import org.sonar.updatecenter.common.Release;
public ExpectedException expectedException = ExpectedException.none();
private AvailableAction underTest = new AvailableAction(userSession, updateCenterFactory);
+ private WsActionTester tester = new WsActionTester(underTest);
@Test
public void action_available_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("available");
-
- WebService.Action action = controller.actions().iterator().next();
+ WebService.Action action = tester.getDef();
+ assertThat(action.key()).isEqualTo("available");
assertThat(action.isPost()).isFalse();
assertThat(action.description()).isNotEmpty();
assertThat(action.responseExample()).isNotNull();
}
@Test
- public void verify_example() throws Exception {
+ public void verify_example() {
logInAsSystemAdministrator();
when(updateCenter.findAvailablePlugins()).thenReturn(of(
pluginUpdate(release(Plugin.factory("abap")
.addOutgoingDependency(release(Plugin.factory("java").setName("Java").setDescription("SonarQube rule engine."), "0.3.6")),
COMPATIBLE)));
- underTest.handle(request, response);
+ TestResponse response = tester.newRequest().execute();
- WsActionTester actionTester = new WsActionTester(underTest);
- assertJson(response.outputAsString()).isSimilarTo(actionTester.getDef().responseExampleAsString());
+ assertJson(response.getInput()).isSimilarTo(tester.getDef().responseExampleAsString());
}
@Test
- public void request_fails_with_ForbiddenException_when_user_is_not_logged_in() throws Exception {
+ public void request_fails_with_ForbiddenException_when_user_is_not_logged_in() {
expectedException.expect(ForbiddenException.class);
- underTest.handle(request, response);
+ tester.newRequest().execute();
}
@Test
- public void request_fails_with_ForbiddenException_when_user_is_not_system_administrator() throws Exception {
+ public void request_fails_with_ForbiddenException_when_user_is_not_system_administrator() {
userSession.logIn().setNonSystemAdministrator();
expectedException.expect(ForbiddenException.class);
- underTest.handle(request, response);
+ tester.newRequest().execute();
}
@Test
- public void empty_array_is_returned_when_there_is_no_plugin_available() throws Exception {
+ public void empty_array_is_returned_when_there_is_no_plugin_available() {
logInAsSystemAdministrator();
- underTest.handle(request, response);
- assertJson(response.outputAsString()).withStrictArrayOrder().isSimilarTo(JSON_EMPTY_PLUGIN_LIST);
+ TestResponse response = tester.newRequest().execute();
+
+ assertJson(response.getInput()).withStrictArrayOrder().isSimilarTo(JSON_EMPTY_PLUGIN_LIST);
}
@Test
- public void empty_array_is_returned_when_update_center_is_not_accessible() throws Exception {
+ public void empty_array_is_returned_when_update_center_is_not_accessible() {
logInAsSystemAdministrator();
when(updateCenterFactory.getUpdateCenter(anyBoolean())).thenReturn(Optional.absent());
- underTest.handle(request, response);
+ TestResponse response = tester.newRequest().execute();
- assertJson(response.outputAsString()).withStrictArrayOrder().isSimilarTo(JSON_EMPTY_PLUGIN_LIST);
+ assertJson(response.getInput()).withStrictArrayOrder().isSimilarTo(JSON_EMPTY_PLUGIN_LIST);
}
@Test
- public void verify_properties_displayed_in_json_per_plugin() throws Exception {
+ public void verify_properties_displayed_in_json_per_plugin() {
logInAsSystemAdministrator();
when(updateCenter.findAvailablePlugins()).thenReturn(of(
pluginUpdate(FULL_PROPERTIES_PLUGIN_RELEASE, COMPATIBLE)));
- underTest.handle(request, response);
+ TestResponse response = tester.newRequest().execute();
- assertJson(response.outputAsString())
- .isSimilarTo(
+ response.assertJson(
"{" +
" \"plugins\": [" +
" {" +
}
@Test
- public void status_COMPATIBLE_is_displayed_COMPATIBLE_in_JSON() throws Exception {
+ public void status_COMPATIBLE_is_displayed_COMPATIBLE_in_JSON() {
logInAsSystemAdministrator();
checkStatusDisplayedInJson(COMPATIBLE, "COMPATIBLE");
}
@Test
- public void status_INCOMPATIBLE_is_displayed_INCOMPATIBLE_in_JSON() throws Exception {
+ public void status_INCOMPATIBLE_is_displayed_INCOMPATIBLE_in_JSON() {
logInAsSystemAdministrator();
checkStatusDisplayedInJson(INCOMPATIBLE, "INCOMPATIBLE");
}
@Test
- public void status_REQUIRE_SONAR_UPGRADE_is_displayed_REQUIRES_SYSTEM_UPGRADE_in_JSON() throws Exception {
+ public void status_REQUIRE_SONAR_UPGRADE_is_displayed_REQUIRES_SYSTEM_UPGRADE_in_JSON() {
logInAsSystemAdministrator();
checkStatusDisplayedInJson(REQUIRE_SONAR_UPGRADE, "REQUIRES_SYSTEM_UPGRADE");
}
@Test
- public void status_DEPENDENCIES_REQUIRE_SONAR_UPGRADE_is_displayed_DEPS_REQUIRE_SYSTEM_UPGRADE_in_JSON() throws Exception {
+ public void status_DEPENDENCIES_REQUIRE_SONAR_UPGRADE_is_displayed_DEPS_REQUIRE_SYSTEM_UPGRADE_in_JSON() {
logInAsSystemAdministrator();
checkStatusDisplayedInJson(DEPENDENCIES_REQUIRE_SONAR_UPGRADE, "DEPS_REQUIRE_SYSTEM_UPGRADE");
}
- private void checkStatusDisplayedInJson(PluginUpdate.Status status, String expectedValue) throws Exception {
+ private void checkStatusDisplayedInJson(PluginUpdate.Status status, String expectedValue) {
when(updateCenter.findAvailablePlugins()).thenReturn(of(
pluginUpdate(release(PLUGIN_1, "1.0.0"), status)));
- underTest.handle(request, response);
+ TestResponse response = tester.newRequest().execute();
- assertJson(response.outputAsString()).isSimilarTo(
+ response.assertJson(
"{" +
" \"plugins\": [" +
" {" +
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
-import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.WebService;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.plugins.PluginDownloader;
import org.sonar.server.plugins.PluginUninstaller;
import org.sonar.server.tester.UserSessionRule;
-import org.sonar.server.ws.WsTester;
+import org.sonar.server.ws.TestResponse;
+import org.sonar.server.ws.WsActionTester;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
public class CancelAllActionTest {
- private static final String DUMMY_CONTROLLER_KEY = "dummy";
-
@Rule
public UserSessionRule userSessionRule = UserSessionRule.standalone();
@Rule
private PluginDownloader pluginDownloader = mock(PluginDownloader.class);
private PluginUninstaller pluginUninstaller = mock(PluginUninstaller.class);
private CancelAllAction underTest = new CancelAllAction(pluginDownloader, pluginUninstaller, userSessionRule);
-
- private Request request = mock(Request.class);
- private WsTester.TestResponse response = new WsTester.TestResponse();
+ private WsActionTester tester = new WsActionTester(underTest);
@Test
public void action_cancel_all_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("cancel_all");
-
- WebService.Action action = controller.actions().iterator().next();
+ WebService.Action action = tester.getDef();
+ assertThat(action.key()).isEqualTo("cancel_all");
assertThat(action.isPost()).isTrue();
assertThat(action.description()).isNotEmpty();
assertThat(action.responseExample()).isNull();
}
@Test
- public void request_fails_with_ForbiddenException_when_user_is_not_logged_in() throws Exception {
+ public void request_fails_with_ForbiddenException_when_user_is_not_logged_in() {
expectedException.expect(ForbiddenException.class);
expectedException.expectMessage("Insufficient privileges");
- underTest.handle(request, response);
+ tester.newRequest().execute();
}
@Test
- public void request_fails_with_ForbiddenException_when_user_is_not_system_administrator() throws Exception {
+ public void request_fails_with_ForbiddenException_when_user_is_not_system_administrator() {
userSessionRule.logIn().setNonSystemAdministrator();
expectedException.expect(ForbiddenException.class);
expectedException.expectMessage("Insufficient privileges");
- underTest.handle(request, response);
+ tester.newRequest().execute();
}
@Test
- public void triggers_cancel_for_downloads_and_uninstalls() throws Exception {
+ public void triggers_cancel_for_downloads_and_uninstalls() {
userSessionRule.logIn().setSystemAdministrator();
- underTest.handle(request, response);
+ TestResponse response = tester.newRequest().execute();
verify(pluginDownloader, times(1)).cancelDownloads();
verify(pluginUninstaller, times(1)).cancelUninstalls();
- assertThat(response.outputAsString()).isEmpty();
+ assertThat(response.getInput()).isEmpty();
}
}
import org.sonar.server.plugins.PluginDownloader;
import org.sonar.server.plugins.UpdateCenterMatrixFactory;
import org.sonar.server.tester.UserSessionRule;
-import org.sonar.server.ws.WsTester;
+import org.sonar.server.ws.TestResponse;
+import org.sonar.server.ws.WsActionTester;
import org.sonar.updatecenter.common.Plugin;
import org.sonar.updatecenter.common.PluginUpdate;
import org.sonar.updatecenter.common.Release;
@RunWith(DataProviderRunner.class)
public class InstallActionTest {
private static final String DUMMY_CONTROLLER_KEY = "dummy";
- private static final String CONTROLLER_KEY = "api/plugins";
private static final String ACTION_KEY = "install";
private static final String KEY_PARAM = "key";
private static final String PLUGIN_KEY = "pluginKey";
@Rule
public UserSessionRule userSessionRule = UserSessionRule.standalone();
+ @Rule
+ public ExpectedException expectedException = ExpectedException.none();
private UpdateCenterMatrixFactory updateCenterFactory = mock(UpdateCenterMatrixFactory.class);
private UpdateCenter updateCenter = mock(UpdateCenter.class);
private PluginDownloader pluginDownloader = mock(PluginDownloader.class);
private InstallAction underTest = new InstallAction(updateCenterFactory, pluginDownloader, userSessionRule);
-
- private WsTester wsTester = new WsTester(new PluginsWs(underTest));
- private WsTester.TestRequest invalidRequest = wsTester.newPostRequest(CONTROLLER_KEY, ACTION_KEY);
- private WsTester.TestRequest validRequest = wsTester.newPostRequest(CONTROLLER_KEY, ACTION_KEY)
- .setParam(KEY_PARAM, PLUGIN_KEY);
-
- @Rule
- public ExpectedException expectedException = ExpectedException.none();
+ private WsActionTester tester = new WsActionTester(underTest);
@Before
public void wireMocks() {
}
@Test
- public void request_fails_with_ForbiddenException_when_user_is_not_logged_in() throws Exception {
+ public void request_fails_with_ForbiddenException_when_user_is_not_logged_in() {
expectedException.expect(ForbiddenException.class);
expectedException.expectMessage("Insufficient privileges");
- validRequest.execute();
+ tester.newRequest().execute();
}
@Test
- public void request_fails_with_ForbiddenException_when_user_is_not_system_administrator() throws Exception {
+ public void request_fails_with_ForbiddenException_when_user_is_not_system_administrator() {
userSessionRule.logIn().setNonSystemAdministrator();
expectedException.expect(ForbiddenException.class);
expectedException.expectMessage("Insufficient privileges");
- validRequest.execute();
+ tester.newRequest().execute();
}
@Test
public void action_install_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(ACTION_KEY);
-
- WebService.Action action = controller.actions().iterator().next();
+ WebService.Action action = tester.getDef();
assertThat(action.isPost()).isTrue();
+ assertThat(action.key()).isEqualTo(ACTION_KEY);
assertThat(action.description()).isNotEmpty();
assertThat(action.responseExample()).isNull();
}
@Test
- public void IAE_is_raised_when_key_param_is_not_provided() throws Exception {
+ public void IAE_is_raised_when_key_param_is_not_provided() {
logInAsSystemAdministrator();
expectedException.expect(IllegalArgumentException.class);
- invalidRequest.execute();
+ tester.newRequest().execute();
}
@Test
- public void IAE_is_raised_when_there_is_no_available_plugin_for_the_key() throws Exception {
+ public void IAE_is_raised_when_there_is_no_available_plugin_for_the_key() {
logInAsSystemAdministrator();
expectedException.expect(IllegalArgumentException.class);
expectedException.expectMessage("No plugin with key 'pluginKey'");
- validRequest.execute();
+ tester.newRequest()
+ .setParam(KEY_PARAM, PLUGIN_KEY)
+ .execute();
}
@Test
@UseDataProvider("editionBundledOrganizationAndLicense")
- public void IAE_is_raised_when_plugin_is_edition_bundled(String organization, String license) throws Exception {
+ public void IAE_is_raised_when_plugin_is_edition_bundled(String organization, String license) {
logInAsSystemAdministrator();
Version version = Version.create("1.0");
when(updateCenter.findAvailablePlugins()).thenReturn(ImmutableList.of(
expectedException.expect(IllegalArgumentException.class);
expectedException.expectMessage("SonarSource commercial plugin with key '" + PLUGIN_KEY + "' can only be installed as part of a SonarSource edition");
- validRequest.execute();
+ tester.newRequest()
+ .setParam(KEY_PARAM, PLUGIN_KEY)
+ .execute();
}
@DataProvider
}
@Test
- public void IAE_is_raised_when_update_center_is_unavailable() throws Exception {
+ public void IAE_is_raised_when_update_center_is_unavailable() {
logInAsSystemAdministrator();
when(updateCenterFactory.getUpdateCenter(anyBoolean())).thenReturn(Optional.absent());
expectedException.expect(IllegalArgumentException.class);
expectedException.expectMessage("No plugin with key 'pluginKey'");
- validRequest.execute();
+ tester.newRequest()
+ .setParam(KEY_PARAM, PLUGIN_KEY)
+ .execute();
}
@Test
- public void if_plugin_is_found_available_download_is_triggered_with_latest_version_from_updatecenter() throws Exception {
+ public void if_plugin_is_found_available_download_is_triggered_with_latest_version_from_updatecenter() {
logInAsSystemAdministrator();
Version version = Version.create("1.0");
when(updateCenter.findAvailablePlugins()).thenReturn(ImmutableList.of(
PluginUpdate.createWithStatus(new Release(Plugin.factory(PLUGIN_KEY), version), PluginUpdate.Status.COMPATIBLE)));
- WsTester.Result result = validRequest.execute();
+ TestResponse response = tester.newRequest()
+ .setParam(KEY_PARAM, PLUGIN_KEY)
+ .execute();
verify(pluginDownloader).download(PLUGIN_KEY, version);
- result.assertNoContent();
+ response.assertNoContent();
}
private void logInAsSystemAdministrator() {
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
-import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.WebService;
import org.sonar.core.platform.PluginInfo;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.plugins.ServerPluginRepository;
import org.sonar.server.plugins.UpdateCenterMatrixFactory;
import org.sonar.server.tester.UserSessionRule;
-import org.sonar.server.ws.WsTester;
+import org.sonar.server.ws.TestResponse;
+import org.sonar.server.ws.WsActionTester;
import org.sonar.updatecenter.common.Plugin;
import org.sonar.updatecenter.common.UpdateCenter;
import org.sonar.updatecenter.common.Version;
private UpdateCenterMatrixFactory updateCenterMatrixFactory = mock(UpdateCenterMatrixFactory.class, RETURNS_DEEP_STUBS);
private PendingAction underTest = new PendingAction(userSession, pluginDownloader, serverPluginRepository,
pluginUninstaller, updateCenterMatrixFactory);
- private Request request = mock(Request.class);
- private WsTester.TestResponse response = new WsTester.TestResponse();
+ private WsActionTester tester = new WsActionTester(underTest);
@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();
+ WebService.Action action = tester.getDef();
assertThat(action.isPost()).isFalse();
+ assertThat(action.key()).isEqualTo("pending");
assertThat(action.description()).isNotEmpty();
assertThat(action.responseExample()).isNotNull();
}
@Test
- public void request_fails_with_ForbiddenException_when_user_is_not_logged_in() throws Exception {
+ public void request_fails_with_ForbiddenException_when_user_is_not_logged_in() {
expectedException.expect(ForbiddenException.class);
- underTest.handle(request, response);
+ tester.newRequest().execute();
}
@Test
- public void request_fails_with_ForbiddenException_when_user_is_not_system_administrator() throws Exception {
+ public void request_fails_with_ForbiddenException_when_user_is_not_system_administrator() {
userSession.logIn().setNonSystemAdministrator();
expectedException.expect(ForbiddenException.class);
- underTest.handle(request, response);
+ tester.newRequest().execute();
}
@Test
- public void empty_arrays_are_returned_when_there_nothing_pending() throws Exception {
+ public void empty_arrays_are_returned_when_there_nothing_pending() {
logInAsSystemAdministrator();
- underTest.handle(request, response);
- assertJson(response.outputAsString()).withStrictArrayOrder().isSimilarTo(
+ TestResponse response = tester.newRequest().execute();
+
+ assertJson(response.getInput()).withStrictArrayOrder().isSimilarTo(
"{" +
" \"installing\": []," +
" \"removing\": []," +
}
@Test
- public void empty_arrays_are_returned_when_update_center_is_unavailable() throws Exception {
+ public void empty_arrays_are_returned_when_update_center_is_unavailable() {
logInAsSystemAdministrator();
when(updateCenterMatrixFactory.getUpdateCenter(false)).thenReturn(Optional.absent());
- underTest.handle(request, response);
+ TestResponse response = tester.newRequest().execute();
- assertJson(response.outputAsString()).withStrictArrayOrder().isSimilarTo(
+ assertJson(response.getInput()).withStrictArrayOrder().isSimilarTo(
"{" +
" \"installing\": []," +
" \"removing\": []," +
}
@Test
- public void verify_properties_displayed_in_json_per_installing_plugin() throws Exception {
+ public void verify_properties_displayed_in_json_per_installing_plugin() {
logInAsSystemAdministrator();
newUpdateCenter("scmgit");
when(pluginDownloader.getDownloadedPlugins()).thenReturn(of(newScmGitPluginInfo()));
- underTest.handle(request, response);
+ TestResponse response = tester.newRequest().execute();
- assertJson(response.outputAsString()).isSimilarTo(
+ response.assertJson(
"{" +
" \"installing\": " +
" [" +
}
@Test
- public void verify_properties_displayed_in_json_per_removing_plugin() throws Exception {
+ public void verify_properties_displayed_in_json_per_removing_plugin() {
logInAsSystemAdministrator();
when(pluginUninstaller.getUninstalledPlugins()).thenReturn(of(newScmGitPluginInfo()));
- underTest.handle(request, response);
+ TestResponse response = tester.newRequest().execute();
- assertJson(response.outputAsString()).isSimilarTo(
+ response.assertJson(
"{" +
" \"installing\": []," +
" \"updating\": []," +
}
@Test
- public void verify_properties_displayed_in_json_per_updating_plugin() throws Exception {
+ public void verify_properties_displayed_in_json_per_updating_plugin() {
logInAsSystemAdministrator();
newUpdateCenter("scmgit");
when(serverPluginRepository.getPluginInfos()).thenReturn(of(newScmGitPluginInfo()));
when(pluginDownloader.getDownloadedPlugins()).thenReturn(of(newScmGitPluginInfo()));
- underTest.handle(request, response);
+ TestResponse response = tester.newRequest().execute();
- assertJson(response.outputAsString()).isSimilarTo(
+ response.assertJson(
"{" +
" \"installing\": []," +
" \"removing\": []," +
}
@Test
- public void verify_properties_displayed_in_json_per_installing_removing_and_updating_plugins() throws Exception {
+ public void verify_properties_displayed_in_json_per_installing_removing_and_updating_plugins() {
logInAsSystemAdministrator();
PluginInfo installed = newPluginInfo("java");
PluginInfo removedPlugin = newPluginInfo("js");
when(pluginUninstaller.getUninstalledPlugins()).thenReturn(of(removedPlugin));
when(pluginDownloader.getDownloadedPlugins()).thenReturn(of(newPlugin, installed));
- underTest.handle(request, response);
+ TestResponse response = tester.newRequest().execute();
- assertJson(response.outputAsString()).isSimilarTo(
+ response.assertJson(
"{" +
" \"installing\":" +
" [" +
}
@Test
- public void installing_plugins_are_sorted_by_name_then_key_and_are_unique() throws Exception {
+ public void installing_plugins_are_sorted_by_name_then_key_and_are_unique() {
logInAsSystemAdministrator();
when(pluginDownloader.getDownloadedPlugins()).thenReturn(of(
newPluginInfo(0).setName("Foo"),
newPluginInfo(3).setName("Bar"),
newPluginInfo(2).setName("Bar")));
- underTest.handle(request, response);
+ TestResponse response = tester.newRequest().execute();
- assertJson(response.outputAsString()).withStrictArrayOrder().isSimilarTo(
+ assertJson(response.getInput()).withStrictArrayOrder().isSimilarTo(
"{" +
" \"installing\": " +
" [" +
}
@Test
- public void removing_plugins_are_sorted_and_unique() throws Exception {
+ public void removing_plugins_are_sorted_and_unique() {
logInAsSystemAdministrator();
when(pluginUninstaller.getUninstalledPlugins()).thenReturn(of(
newPluginInfo(0).setName("Foo"),
newPluginInfo(3).setName("Bar"),
newPluginInfo(2).setName("Bar")));
- underTest.handle(request, response);
+ TestResponse response = tester.newRequest().execute();
- assertJson(response.outputAsString()).withStrictArrayOrder().isSimilarTo(
+ assertJson(response.getInput()).withStrictArrayOrder().isSimilarTo(
"{" +
" \"installing\": []," +
" \"updating\": []," +
import org.sonar.db.plugin.PluginDto;
import org.sonar.server.plugins.InstalledPlugin;
import org.sonar.server.plugins.InstalledPlugin.FileAndMd5;
-import org.sonar.server.ws.WsTester;
+import org.sonar.server.ws.DumbResponse;
import org.sonar.updatecenter.common.Plugin;
import org.sonar.updatecenter.common.PluginUpdate;
import org.sonar.updatecenter.common.Release;
@Rule
public TemporaryFolder temp = new TemporaryFolder();
- private WsTester.TestResponse response = new WsTester.TestResponse();
+ private DumbResponse response = new DumbResponse();
private JsonWriter jsonWriter = response.newJsonWriter();
@Test
public void verify_properties_written_by_writePluginMetadata() {
+
PluginWSCommons.writePluginInfo(jsonWriter, gitPluginInfo(), null, null, null);
jsonWriter.close();
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.Response;
import org.sonar.api.server.ws.WebService;
-import org.sonar.server.ws.WsTester;
import static org.assertj.core.api.Assertions.assertThat;
public class PluginsWsTest {
- private WsTester tester = new WsTester(new PluginsWs(new DummyPluginsWsAction()));
+ private PluginsWs underTest = new PluginsWs(new DummyPluginsWsAction());
@Test
public void defines_controller_and_binds_PluginsWsActions() {
- WebService.Controller controller = tester.controller("api/plugins");
+ WebService.Context context = new WebService.Context();
+ underTest.define(context);
+
+ WebService.Controller controller = context.controller("api/plugins");
assertThat(controller).isNotNull();
assertThat(controller.since()).isEqualTo("5.2");
assertThat(controller.description()).isNotEmpty();
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
-import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.WebService;
import org.sonar.core.platform.PluginInfo;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.plugins.PluginUninstaller;
import org.sonar.server.plugins.ServerPluginRepository;
import org.sonar.server.tester.UserSessionRule;
-import org.sonar.server.ws.WsTester;
+import org.sonar.server.ws.TestResponse;
+import org.sonar.server.ws.WsActionTester;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
@RunWith(DataProviderRunner.class)
public class UninstallActionTest {
- private static final String DUMMY_CONTROLLER_KEY = "dummy";
private static final String CONTROLLER_KEY = "api/plugins";
private static final String ACTION_KEY = "uninstall";
private static final String KEY_PARAM = "key";
private ServerPluginRepository serverPluginRepository = mock(ServerPluginRepository.class);
private PluginUninstaller pluginUninstaller = mock(PluginUninstaller.class);
private UninstallAction underTest = new UninstallAction(serverPluginRepository, pluginUninstaller, userSessionRule);
-
- private WsTester wsTester = new WsTester(new PluginsWs(underTest));
- private Request invalidRequest = wsTester.newGetRequest(CONTROLLER_KEY, ACTION_KEY);
- private Request validRequest = wsTester.newGetRequest(CONTROLLER_KEY, ACTION_KEY).setParam(KEY_PARAM, PLUGIN_KEY);
- private WsTester.TestResponse response = new WsTester.TestResponse();
+ private WsActionTester tester = new WsActionTester(underTest);
@Test
- public void request_fails_with_ForbiddenException_when_user_is_not_logged_in() throws Exception {
+ public void request_fails_with_ForbiddenException_when_user_is_not_logged_in() {
expectedException.expect(ForbiddenException.class);
expectedException.expectMessage("Insufficient privileges");
- underTest.handle(validRequest, response);
+ tester.newRequest().execute();
}
@Test
- public void request_fails_with_ForbiddenException_when_user_is_not_system_administrator() throws Exception {
+ public void request_fails_with_ForbiddenException_when_user_is_not_system_administrator() {
userSessionRule.logIn().setNonSystemAdministrator();
expectedException.expect(ForbiddenException.class);
expectedException.expectMessage("Insufficient privileges");
- underTest.handle(validRequest, response);
+ tester.newRequest().execute();
}
@Test
public void action_uninstall_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(ACTION_KEY);
-
- WebService.Action action = controller.actions().iterator().next();
+ WebService.Action action = tester.getDef();
+ assertThat(action.key()).isEqualTo(ACTION_KEY);
assertThat(action.isPost()).isTrue();
assertThat(action.description()).isNotEmpty();
assertThat(action.responseExample()).isNull();
}
@Test
- public void IAE_is_raised_when_key_param_is_not_provided() throws Exception {
+ public void IAE_is_raised_when_key_param_is_not_provided() {
logInAsSystemAdministrator();
expectedException.expect(IllegalArgumentException.class);
- underTest.handle(invalidRequest, response);
+ tester.newRequest().execute();
}
@Test
- public void do_not_attempt_uninstall_if_no_plugin_in_repository_for_specified_key() throws Exception {
+ public void do_not_attempt_uninstall_if_no_plugin_in_repository_for_specified_key() {
logInAsSystemAdministrator();
when(serverPluginRepository.getPluginInfo(PLUGIN_KEY)).thenReturn(null);
- underTest.handle(validRequest, response);
+ tester.newRequest()
+ .setParam(KEY_PARAM, PLUGIN_KEY)
+ .execute();
verifyZeroInteractions(pluginUninstaller);
}
@Test
@UseDataProvider("editionBundledOrganizationAndLicense")
- public void IAE_is_raised_when_plugin_is_installed_and_is_edition_bundled(String organization, String license) throws Exception {
+ public void IAE_is_raised_when_plugin_is_installed_and_is_edition_bundled(String organization, String license) {
logInAsSystemAdministrator();
when(serverPluginRepository.getPluginInfo(PLUGIN_KEY))
.thenReturn(new PluginInfo(PLUGIN_KEY)
expectedException.expect(IllegalArgumentException.class);
expectedException.expectMessage("SonarSource commercial plugin with key '" + PLUGIN_KEY + "' can only be uninstalled as part of a SonarSource edition");
- underTest.handle(validRequest, response);
+ tester.newRequest()
+ .setParam(KEY_PARAM, PLUGIN_KEY)
+ .execute();
}
@DataProvider
}
@Test
- public void if_plugin_is_installed_uninstallation_is_triggered() throws Exception {
+ public void if_plugin_is_installed_uninstallation_is_triggered() {
logInAsSystemAdministrator();
when(serverPluginRepository.getPluginInfo(PLUGIN_KEY)).thenReturn(new PluginInfo(PLUGIN_KEY));
- underTest.handle(validRequest, response);
+ TestResponse response = tester.newRequest()
+ .setParam(KEY_PARAM, PLUGIN_KEY)
+ .execute();
verify(pluginUninstaller).uninstall(PLUGIN_KEY);
- assertThat(response.outputAsString()).isEmpty();
+ assertThat(response.getInput()).isEmpty();
}
private void logInAsSystemAdministrator() {
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
-import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.WebService;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.plugins.PluginDownloader;
import org.sonar.server.plugins.UpdateCenterMatrixFactory;
import org.sonar.server.tester.UserSessionRule;
-import org.sonar.server.ws.WsTester;
+import org.sonar.server.ws.TestResponse;
+import org.sonar.server.ws.WsActionTester;
import org.sonar.updatecenter.common.Plugin;
import org.sonar.updatecenter.common.PluginUpdate;
import org.sonar.updatecenter.common.PluginUpdate.Status;
import static org.mockito.Mockito.when;
public class UpdateActionTest {
- private static final String DUMMY_CONTROLLER_KEY = "dummy";
- private static final String CONTROLLER_KEY = "api/plugins";
private static final String ACTION_KEY = "update";
private static final String KEY_PARAM = "key";
private static final String PLUGIN_KEY = "pluginKey";
private UpdateCenter updateCenter = mock(UpdateCenter.class);
private PluginDownloader pluginDownloader = mock(PluginDownloader.class);
private UpdateAction underTest = new UpdateAction(updateCenterFactory, pluginDownloader, userSessionRule);
-
- private WsTester wsTester = new WsTester(new PluginsWs(underTest));
- private Request invalidRequest = wsTester.newGetRequest(CONTROLLER_KEY, ACTION_KEY);
- private Request validRequest = wsTester.newGetRequest(CONTROLLER_KEY, ACTION_KEY).setParam(KEY_PARAM, PLUGIN_KEY);
- private WsTester.TestResponse response = new WsTester.TestResponse();
+ private WsActionTester tester = new WsActionTester(underTest);
@Rule
public ExpectedException expectedException = ExpectedException.none();
}
@Test
- public void request_fails_with_ForbiddenException_when_user_is_not_logged_in() throws Exception {
+ public void request_fails_with_ForbiddenException_when_user_is_not_logged_in() {
expectedException.expect(ForbiddenException.class);
expectedException.expectMessage("Insufficient privileges");
- underTest.handle(validRequest, response);
+ tester.newRequest().execute();
}
@Test
- public void request_fails_with_ForbiddenException_when_user_is_not_system_administrator() throws Exception {
+ public void request_fails_with_ForbiddenException_when_user_is_not_system_administrator() {
userSessionRule.logIn().setNonSystemAdministrator();
expectedException.expect(ForbiddenException.class);
expectedException.expectMessage("Insufficient privileges");
- underTest.handle(validRequest, response);
+ tester.newRequest().execute();
}
@Test
public void action_update_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(ACTION_KEY);
-
- WebService.Action action = controller.actions().iterator().next();
+ WebService.Action action = tester.getDef();
+ assertThat(action.key()).isEqualTo(ACTION_KEY);
assertThat(action.isPost()).isTrue();
assertThat(action.description()).isNotEmpty();
assertThat(action.responseExample()).isNull();
}
@Test
- public void IAE_is_raised_when_key_param_is_not_provided() throws Exception {
+ public void IAE_is_raised_when_key_param_is_not_provided() {
logInAsSystemAdministrator();
expectedException.expect(IllegalArgumentException.class);
- underTest.handle(invalidRequest, response);
+ tester.newRequest().execute();
}
@Test
- public void IAE_is_raised_when_there_is_no_plugin_update_for_the_key() throws Exception {
+ public void IAE_is_raised_when_there_is_no_plugin_update_for_the_key() {
logInAsSystemAdministrator();
expectedException.expect(IllegalArgumentException.class);
expectedException.expectMessage("No plugin with key 'pluginKey'");
- underTest.handle(validRequest, response);
+ tester.newRequest()
+ .setParam(KEY_PARAM, PLUGIN_KEY)
+ .execute();
}
@Test
- public void IAE_is_raised_when_update_center_is_unavailable() throws Exception {
+ public void IAE_is_raised_when_update_center_is_unavailable() {
logInAsSystemAdministrator();
when(updateCenterFactory.getUpdateCenter(anyBoolean())).thenReturn(Optional.absent());
expectedException.expect(IllegalArgumentException.class);
expectedException.expectMessage("No plugin with key 'pluginKey'");
- underTest.handle(validRequest, response);
+ tester.newRequest()
+ .setParam(KEY_PARAM, PLUGIN_KEY)
+ .execute();
}
@Test
- public void if_plugin_has_an_update_download_is_triggered_with_latest_version_from_updatecenter() throws Exception {
+ public void if_plugin_has_an_update_download_is_triggered_with_latest_version_from_updatecenter() {
logInAsSystemAdministrator();
Version version = Version.create("1.0");
when(updateCenter.findPluginUpdates()).thenReturn(ImmutableList.of(
PluginUpdate.createWithStatus(new Release(Plugin.factory(PLUGIN_KEY), version), Status.COMPATIBLE)));
- underTest.handle(validRequest, response);
+ TestResponse response = tester.newRequest()
+ .setParam(KEY_PARAM, PLUGIN_KEY)
+ .execute();
verify(pluginDownloader).download(PLUGIN_KEY, version);
- assertThat(response.outputAsString()).isEmpty();
+ assertThat(response.getInput()).isEmpty();
}
private void logInAsSystemAdministrator() {
import org.sonar.api.utils.DateUtils;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.tester.UserSessionRule;
+import org.sonar.server.ws.TestResponse;
import org.sonar.server.ws.WsActionTester;
-import org.sonar.server.ws.WsTester;
import org.sonar.updatecenter.common.Plugin;
import org.sonar.updatecenter.common.Release;
public ExpectedException expectedException = ExpectedException.none();
private UpdatesAction underTest = new UpdatesAction(userSession, updateCenterFactory, new PluginUpdateAggregator());
+ private WsActionTester tester = new WsActionTester(underTest);
@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();
+ WebService.Action action = tester.getDef();
assertThat(action.isPost()).isFalse();
+ assertThat(action.key()).isEqualTo("updates");
assertThat(action.description()).isNotEmpty();
assertThat(action.responseExample()).isNotNull();
}
@Test
- public void request_fails_with_ForbiddenException_when_user_is_not_logged_in() throws Exception {
+ public void request_fails_with_ForbiddenException_when_user_is_not_logged_in() {
expectedException.expect(ForbiddenException.class);
- underTest.handle(request, response);
+ tester.newRequest().execute();
}
@Test
- public void request_fails_with_ForbiddenException_when_user_is_not_system_administrator() throws Exception {
+ public void request_fails_with_ForbiddenException_when_user_is_not_system_administrator() {
userSession.logIn();
expectedException.expect(ForbiddenException.class);
- underTest.handle(request, response);
+ tester.newRequest().execute();
}
@Test
- public void empty_array_is_returned_when_there_is_no_plugin_available() throws Exception {
+ public void empty_array_is_returned_when_there_is_no_plugin_available() {
logInAsSystemAdministrator();
- underTest.handle(request, response);
+ TestResponse response = tester.newRequest().execute();
- assertJson(response.outputAsString()).withStrictArrayOrder().isSimilarTo(JSON_EMPTY_PLUGIN_LIST);
+ assertJson(response.getInput()).withStrictArrayOrder().isSimilarTo(JSON_EMPTY_PLUGIN_LIST);
}
@Test
- public void verify_response_against_example() throws Exception {
+ public void verify_response_against_example() {
logInAsSystemAdministrator();
when(updateCenter.findPluginUpdates()).thenReturn(of(
pluginUpdate(ABAP_32, COMPATIBLE),
pluginUpdate(ABAP_31, INCOMPATIBLE),
pluginUpdate(ANDROID_10, COMPATIBLE)));
- underTest.handle(request, response);
+ TestResponse response = tester.newRequest().execute();
- assertJson(response.outputAsString())
+ assertJson(response.getInput())
.isSimilarTo(new WsActionTester(underTest).getDef().responseExampleAsString());
}
@Test
- public void status_COMPATIBLE_is_displayed_COMPATIBLE_in_JSON() throws Exception {
+ public void status_COMPATIBLE_is_displayed_COMPATIBLE_in_JSON() {
logInAsSystemAdministrator();
when(updateCenter.findPluginUpdates()).thenReturn(of(
pluginUpdate(release(PLUGIN_1, "1.0.0"), COMPATIBLE)));
- underTest.handle(request, response);
+ TestResponse response = tester.newRequest().execute();
- assertJson(response.outputAsString()).isSimilarTo(
+ response.assertJson(
"{" +
" \"plugins\": [" +
" {" +
}
@Test
- public void plugins_are_sorted_by_name_and_made_unique() throws Exception {
+ public void plugins_are_sorted_by_name_and_made_unique() {
logInAsSystemAdministrator();
when(updateCenter.findPluginUpdates()).thenReturn(of(
pluginUpdate("key2", "name2"),
pluginUpdate("key0", "name0"),
pluginUpdate("key1", "name1")));
- underTest.handle(request, response);
+ TestResponse response = tester.newRequest().execute();
- assertJson(response.outputAsString()).withStrictArrayOrder().isSimilarTo(
+ assertJson(response.getInput()).withStrictArrayOrder().isSimilarTo(
"{" +
" \"plugins\": [" +
" {" +
import org.sonar.server.project.Project;
import org.sonar.server.project.ProjectLifeCycleListeners;
import org.sonar.server.tester.UserSessionRule;
-import org.sonar.server.ws.WsTester;
+import org.sonar.server.ws.TestRequest;
+import org.sonar.server.ws.TestResponse;
+import org.sonar.server.ws.WsActionTester;
import static java.util.Collections.singleton;
import static org.assertj.core.api.Assertions.assertThat;
import static org.sonar.db.permission.OrganizationPermission.ADMINISTER;
import static org.sonar.db.user.UserTesting.newUserDto;
import static org.sonar.server.component.TestComponentFinder.from;
-import static org.sonarqube.ws.client.project.ProjectsWsParameters.CONTROLLER;
import static org.sonarqube.ws.client.project.ProjectsWsParameters.PARAM_PROJECT;
public class DeleteActionTest {
private ComponentDbTester componentDbTester = new ComponentDbTester(db);
private ComponentCleanerService componentCleanerService = mock(ComponentCleanerService.class);
private ProjectLifeCycleListeners projectLifeCycleListeners = mock(ProjectLifeCycleListeners.class);
- private WsTester ws = new WsTester(new ProjectsWs(
- new DeleteAction(
- componentCleanerService,
- from(db),
- dbClient,
- userSessionRule, projectLifeCycleListeners)));
+ private DeleteAction underTest = new DeleteAction(
+ componentCleanerService,
+ from(db),
+ dbClient,
+ userSessionRule, projectLifeCycleListeners);
+ private WsActionTester tester = new WsActionTester(underTest);
@Test
- public void organization_administrator_deletes_project_by_key() throws Exception {
+ public void organization_administrator_deletes_project_by_key() {
ComponentDto project = componentDbTester.insertPrivateProject();
userSessionRule.logIn().addPermission(ADMINISTER, project.getOrganizationUuid());
- call(newRequest().setParam(PARAM_PROJECT, project.getDbKey()));
+ call(tester.newRequest().setParam(PARAM_PROJECT, project.getDbKey()));
assertThat(verifyDeletedKey()).isEqualTo(project.getDbKey());
verify(projectLifeCycleListeners).onProjectsDeleted(singleton(Project.from(project)));
}
@Test
- public void project_administrator_deletes_the_project_by_key() throws Exception {
+ public void project_administrator_deletes_the_project_by_key() {
ComponentDto project = componentDbTester.insertPrivateProject();
userSessionRule.logIn().addProjectPermission(ADMIN, project);
- call(newRequest().setParam(PARAM_PROJECT, project.getDbKey()));
+ call(tester.newRequest().setParam(PARAM_PROJECT, project.getDbKey()));
assertThat(verifyDeletedKey()).isEqualTo(project.getDbKey());
verify(projectLifeCycleListeners).onProjectsDeleted(singleton(Project.from(project)));
}
@Test
- public void project_deletion_also_ensure_that_homepage_on_this_project_if_it_exists_is_cleared() throws Exception {
+ public void project_deletion_also_ensure_that_homepage_on_this_project_if_it_exists_is_cleared() {
ComponentDto project = componentDbTester.insertPrivateProject();
UserDto insert = dbClient.userDao().insert(dbSession,
newUserDto().setHomepageType("PROJECT").setHomepageParameter(project.uuid()));
dbSession.commit();
-
userSessionRule.logIn().addProjectPermission(ADMIN, project);
+ DeleteAction underTest = new DeleteAction(
+ new ComponentCleanerService(dbClient, new ResourceTypesRule().setAllQualifiers(PROJECT),
+ new TestProjectIndexers()),
+ from(db), dbClient, userSessionRule, projectLifeCycleListeners);
- new WsTester(new ProjectsWs(
- new DeleteAction(
- new ComponentCleanerService(dbClient, new ResourceTypesRule().setAllQualifiers(PROJECT),
- new TestProjectIndexers()),
- from(db), dbClient, userSessionRule, projectLifeCycleListeners)))
- .newPostRequest(CONTROLLER, ACTION)
- .setParam(PARAM_PROJECT, project.getDbKey())
- .execute();
+ new WsActionTester(underTest)
+ .newRequest()
+ .setParam(PARAM_PROJECT, project.getDbKey())
+ .execute();
UserDto userReloaded = dbClient.userDao().selectUserById(dbSession, insert.getId());
assertThat(userReloaded.getHomepageType()).isNull();
}
@Test
- public void project_deletion_also_ensure_that_webhooks_on_this_project_if_they_exists_are_deleted() throws Exception {
+ public void project_deletion_also_ensure_that_webhooks_on_this_project_if_they_exists_are_deleted() {
ComponentDto project = componentDbTester.insertPrivateProject();
webhookDbTester.insertWebhook(project);
webhookDbTester.insertWebhook(project);
webhookDbTester.insertWebhook(project);
userSessionRule.logIn().addProjectPermission(ADMIN, project);
+ DeleteAction underTest = new DeleteAction(
+ new ComponentCleanerService(dbClient, new ResourceTypesRule().setAllQualifiers(PROJECT),
+ new TestProjectIndexers()),
+ from(db), dbClient, userSessionRule, projectLifeCycleListeners);
- new WsTester(new ProjectsWs(
- new DeleteAction(
- new ComponentCleanerService(dbClient, new ResourceTypesRule().setAllQualifiers(PROJECT),
- new TestProjectIndexers()),
- from(db), dbClient, userSessionRule, projectLifeCycleListeners)))
- .newPostRequest(CONTROLLER, ACTION)
- .setParam(PARAM_PROJECT, project.getDbKey())
- .execute();
+ new WsActionTester(underTest)
+ .newRequest()
+ .setParam(PARAM_PROJECT, project.getDbKey())
+ .execute();
List<WebhookDto> webhookDtos = dbClient.webhookDao().selectByProject(dbSession, project);
assertThat(webhookDtos).isEmpty();
}
@Test
- public void return_403_if_not_project_admin_nor_org_admin() throws Exception {
+ public void return_403_if_not_project_admin_nor_org_admin() {
ComponentDto project = componentDbTester.insertPrivateProject();
userSessionRule.logIn()
.addProjectPermission(UserRole.USER, project);
expectedException.expect(ForbiddenException.class);
- call(newRequest().setParam(PARAM_PROJECT, project.getDbKey()));
+ call(tester.newRequest().setParam(PARAM_PROJECT, project.getDbKey()));
}
@Test
- public void return_401_if_not_logged_in() throws Exception {
+ public void return_401_if_not_logged_in() {
ComponentDto project = componentDbTester.insertPrivateProject();
userSessionRule.anonymous();
expectedException.expect(UnauthorizedException.class);
- call(newRequest().setParam(PARAM_PROJECT, project.getDbKey()));
+ call(tester.newRequest().setParam(PARAM_PROJECT, project.getDbKey()));
}
@Test
- public void fail_when_using_branch_db_key() throws Exception {
+ public void fail_when_using_branch_db_key() {
ComponentDto project = db.components().insertMainBranch();
userSessionRule.logIn().addProjectPermission(UserRole.USER, project);
ComponentDto branch = db.components().insertProjectBranch(project);
expectedException.expect(NotFoundException.class);
expectedException.expectMessage(String.format("Component key '%s' not found", branch.getDbKey()));
- call(newRequest().setParam(PARAM_PROJECT, branch.getDbKey()));
+ call(tester.newRequest().setParam(PARAM_PROJECT, branch.getDbKey()));
}
private String verifyDeletedKey() {
return argument.getValue().getDbKey();
}
- private WsTester.TestRequest newRequest() {
- return ws.newPostRequest(CONTROLLER, ACTION);
- }
-
- private void call(WsTester.TestRequest request) throws Exception {
- WsTester.Result result = request.execute();
+ private void call(TestRequest request) {
+ TestResponse result = request.execute();
result.assertNoContent();
}
}
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.Response;
import org.sonar.api.server.ws.WebService;
-import org.sonar.server.ws.WsTester;
import static java.util.Collections.singletonList;
import static org.assertj.core.api.Assertions.assertThat;
public class ProjectTagsWsTest {
- private WsTester ws = new WsTester(new ProjectTagsWs(singletonList(new FakeAction())));
-
- private WebService.Controller underTest = ws.controller("api/project_tags");
+ private ProjectTagsWs underTest = new ProjectTagsWs(singletonList(new FakeAction()));
@Test
public void definition() {
- assertThat(underTest.path()).isEqualTo("api/project_tags");
- assertThat(underTest.since()).isEqualTo("6.4");
- assertThat(underTest.description()).isNotEmpty();
+ WebService.Context context = new WebService.Context();
+
+ underTest.define(context);
+
+ WebService.Controller controller = context.controller("api/project_tags");
+ assertThat(controller.path()).isEqualTo("api/project_tags");
+ assertThat(controller.since()).isEqualTo("6.4");
+ assertThat(controller.description()).isNotEmpty();
}
private static class FakeAction implements ProjectTagsWsAction {
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
+import org.sonar.api.impl.ws.SimpleGetRequest;
import org.sonar.api.resources.Languages;
import org.sonar.api.server.ws.WebService;
-import org.sonar.api.impl.ws.SimpleGetRequest;
-import org.sonar.server.ws.WsTester;
import static org.assertj.core.api.Assertions.assertThat;
import static org.sonar.server.language.LanguageTesting.newLanguage;
@Test
public void define_ws_parameters() {
- WsTester wsTester = new WsTester();
- WebService.NewController controller = wsTester.context().createController("api/qualityprofiles");
+ WebService.Context context = new WebService.Context();
+ WebService.NewController controller = context.createController("api/qualityprofiles");
WebService.NewAction newAction = controller.createAction("do").setHandler((request, response) -> {
});
QProfileReference.defineParams(newAction, languages);
controller.done();
- WebService.Action action = wsTester.controller("api/qualityprofiles").action("do");
+ WebService.Action action = context.controller("api/qualityprofiles").action("do");
assertThat(action.param("language")).isNotNull();
assertThat(action.param("language").possibleValues()).containsOnly("java", "js");
assertThat(action.param("key")).isNotNull();
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.Response;
import org.sonar.api.server.ws.WebService;
-import org.sonar.server.ws.WsTester;
import static org.assertj.core.api.Assertions.assertThat;
public class RootsWsTest {
private RootsWs underTest = new RootsWs(new DummyRootsWsAction());
- private WsTester wsTester = new WsTester(underTest);
@Test
public void verify_definition() {
- assertThat(wsTester.context().controllers()).hasSize(1);
- WebService.Controller controller = wsTester.context().controller("api/roots");
+ WebService.Context context = new WebService.Context();
+
+ underTest.define(context);
+
+ assertThat(context.controllers()).hasSize(1);
+ WebService.Controller controller = context.controller("api/roots");
assertThat(controller.description()).isEqualTo("Manage root users");
assertThat(controller.since()).isEqualTo("6.2");
}
import org.sonar.db.DbSession;
import org.sonar.db.DbTester;
import org.sonar.db.rule.RuleRepositoryDto;
-import org.sonar.server.ws.WsTester;
-import org.sonar.server.ws.WsTester.TestRequest;
+import org.sonar.server.ws.TestRequest;
+import org.sonar.server.ws.WsActionTester;
import static java.util.Arrays.asList;
public class RepositoriesActionTest {
private static final String EMPTY_JSON_RESPONSE = "{\"repositories\":[]}";
- private WsTester wsTester;
@Rule
public DbTester dbTester = DbTester.create(System2.INSTANCE);
+
+ private RepositoriesAction underTest = new RepositoriesAction(dbTester.getDbClient());
+ private WsActionTester tester = new WsActionTester(underTest);
@Before
public void setUp() {
RuleRepositoryDto repo3 = new RuleRepositoryDto("common-ws", "ws", "SonarQube Common");
dbTester.getDbClient().ruleRepositoryDao().insertOrUpdate(dbSession, asList(repo1, repo2, repo3));
dbSession.commit();
-
- wsTester = new WsTester(new RulesWs(new RepositoriesAction(dbTester.getDbClient())));
}
@Test
- public void should_list_repositories() throws Exception {
+ public void should_list_repositories() {
newRequest().execute().assertJson(this.getClass(), "repositories.json");
newRequest().setParam("language", "xoo").execute().assertJson(this.getClass(), "repositories_xoo.json");
newRequest().setParam("language", "ws").execute().assertJson(this.getClass(), "repositories_ws.json");
}
@Test
- public void filter_repositories_by_name() throws Exception {
+ public void filter_repositories_by_name() {
newRequest().setParam("q", "common").execute().assertJson(this.getClass(), "repositories_common.json");
newRequest().setParam("q", "squid").execute().assertJson(this.getClass(), "repositories_squid.json");
newRequest().setParam("q", "sonar").execute().assertJson(this.getClass(), "repositories_sonar.json");
}
@Test
- public void do_not_consider_query_as_regexp_when_filtering_repositories_by_name() throws Exception {
+ public void do_not_consider_query_as_regexp_when_filtering_repositories_by_name() {
// invalid regexp : do not fail. Query is not a regexp.
newRequest().setParam("q", "[").execute().assertJson(EMPTY_JSON_RESPONSE);
}
protected TestRequest newRequest() {
- return wsTester.newGetRequest("api/rules", "repositories");
+ return tester.newRequest();
}
}
import org.sonar.server.source.SourceService;
import org.sonar.server.source.index.FileSourceTesting;
import org.sonar.server.tester.UserSessionRule;
-import org.sonar.server.ws.WsTester;
-import org.sonar.server.ws.WsTester.TestRequest;
+import org.sonar.server.ws.TestRequest;
+import org.sonar.server.ws.TestResponse;
+import org.sonar.server.ws.WsActionTester;
import static java.lang.String.format;
import static org.mockito.ArgumentMatchers.anyString;
private SnapshotDao snapshotDao = new SnapshotDao();
private ComponentDto privateProject;
private OrganizationDto organization;
- private WsTester wsTester;
+ private HtmlSourceDecorator htmlSourceDecorator = mock(HtmlSourceDecorator.class);
+ private SourceService sourceService = new SourceService(db.getDbClient(), htmlSourceDecorator);
+ private LinesJsonWriter linesJsonWriter = new LinesJsonWriter(htmlSourceDecorator);
+ private LinesAction underTest = new LinesAction(TestComponentFinder.from(db), db.getDbClient(), sourceService, linesJsonWriter, userSession);
+ private WsActionTester tester = new WsActionTester(underTest);
@Before
public void setUp() {
- HtmlSourceDecorator htmlSourceDecorator = mock(HtmlSourceDecorator.class);
- when(htmlSourceDecorator.getDecoratedSourceAsHtml(anyString(), anyString(), anyString())).then((Answer<String>)
- invocationOnMock -> "<p>" + invocationOnMock.getArguments()[0] + "</p>");
- LinesJsonWriter linesJsonWriter = new LinesJsonWriter(htmlSourceDecorator);
- SourceService sourceService = new SourceService(db.getDbClient(), htmlSourceDecorator);
- wsTester = new WsTester(new SourcesWs(
- new LinesAction(TestComponentFinder.from(db), db.getDbClient(), sourceService, linesJsonWriter, userSession)));
+ when(htmlSourceDecorator.getDecoratedSourceAsHtml(anyString(), anyString(), anyString()))
+ .then((Answer<String>) invocationOnMock -> "<p>" + invocationOnMock.getArguments()[0] + "</p>");
organization = db.organizations().insert();
privateProject = ComponentTesting.newPrivateProjectDto(organization);
}
@Test
- public void show_source() throws Exception {
+ public void show_source() {
ComponentDto file = insertFileWithData(FileSourceTesting.newFakeData(3).build(), privateProject);
setUserWithValidPermission(file);
- TestRequest request = wsTester.newGetRequest("api/sources", "lines").setParam("uuid", file.uuid());
- request.execute().assertJson(getClass(), "show_source.json");
+ TestResponse response = tester.newRequest()
+ .setParam("uuid", file.uuid())
+ .execute();
+
+ response.assertJson(getClass(), "show_source.json");
}
@Test
- public void fail_to_show_source_if_no_source_found() throws Exception {
+ public void fail_to_show_source_if_no_source_found() {
ComponentDto file = insertFile(privateProject);
setUserWithValidPermission(file);
+ TestRequest request = tester.newRequest()
+ .setParam("uuid", file.uuid());
+
expectedException.expect(NotFoundException.class);
- wsTester.newGetRequest("api/sources", "lines").setParam("uuid", file.uuid()).execute();
+
+ request.execute();
}
@Test
- public void show_paginated_lines() throws Exception {
+ public void show_paginated_lines() {
ComponentDto file = insertFileWithData(FileSourceTesting.newFakeData(3).build(), privateProject);
setUserWithValidPermission(file);
- wsTester
- .newGetRequest("api/sources", "lines")
+ tester
+ .newRequest()
.setParam("uuid", file.uuid())
.setParam("from", "3")
.setParam("to", "3")
}
@Test
- public void branch() throws Exception {
+ public void branch() {
ComponentDto project = db.components().insertMainBranch();
userSession.addProjectPermission(UserRole.USER, project);
ComponentDto branch = db.components().insertProjectBranch(project);
.addMembership(db.getDefaultOrganization())
.addProjectPermission(UserRole.CODEVIEWER, project, file);
- wsTester.newGetRequest("api/sources", "lines")
+ tester.newRequest()
.setParam("key", file.getKey())
.setParam("branch", file.getBranch())
.execute()
}
@Test
- public void pull_request() throws Exception {
+ public void pull_request() {
ComponentDto project = db.components().insertMainBranch();
userSession.addProjectPermission(UserRole.USER, project);
ComponentDto branch = db.components().insertProjectBranch(project, b -> b.setBranchType(PULL_REQUEST));
.addMembership(db.getDefaultOrganization())
.addProjectPermission(UserRole.CODEVIEWER, project, file);
- wsTester.newGetRequest("api/sources", "lines")
+ tester.newRequest()
.setParam("key", file.getKey())
.setParam("pullRequest", file.getPullRequest())
.execute()
}
@Test
- public void fail_when_no_uuid_or_key_param() throws Exception {
+ public void fail_when_no_uuid_or_key_param() {
expectedException.expect(IllegalArgumentException.class);
expectedException.expectMessage("Either 'uuid' or 'key' must be provided");
- TestRequest request = wsTester.newGetRequest("api/sources", "lines");
- request.execute();
+ tester.newRequest().execute();
}
@Test
- public void fail_when_file_key_does_not_exist() throws Exception {
+ public void fail_when_file_key_does_not_exist() {
expectedException.expect(NotFoundException.class);
expectedException.expectMessage("Component key 'Foo.java' not found");
- TestRequest request = wsTester.newGetRequest("api/sources", "lines").setParam("key", "Foo.java");
- request.execute();
+ tester.newRequest().setParam("key", "Foo.java").execute();
}
@Test
- public void fail_when_file_uuid_does_not_exist() throws Exception {
+ public void fail_when_file_uuid_does_not_exist() {
expectedException.expect(NotFoundException.class);
expectedException.expectMessage("Component id 'ABCD' not found");
- TestRequest request = wsTester.newGetRequest("api/sources", "lines").setParam("uuid", "ABCD");
- request.execute();
+ tester.newRequest().setParam("uuid", "ABCD").execute();
}
@Test
- public void fail_when_file_is_removed() throws Exception {
+ public void fail_when_file_is_removed() {
ComponentDto file = newFileDto(privateProject).setDbKey("file-key").setEnabled(false);
db.components().insertComponents(privateProject, file);
setUserWithValidPermission(file);
expectedException.expect(NotFoundException.class);
expectedException.expectMessage("Component key 'file-key' not found");
- TestRequest request = wsTester.newGetRequest("api/sources", "lines").setParam("key", "file-key");
- request.execute();
+ tester.newRequest().setParam("key", "file-key").execute();
}
@Test(expected = ForbiddenException.class)
- public void check_permission() throws Exception {
+ public void check_permission() {
ComponentDto file = insertFileWithData(FileSourceTesting.newFakeData(1).build(), privateProject);
userSession.logIn("login");
- wsTester.newGetRequest("api/sources", "lines")
+ tester.newRequest()
.setParam("uuid", file.uuid())
.execute();
}
@Test
- public void display_deprecated_fields() throws Exception {
+ public void display_deprecated_fields() {
ComponentDto file = insertFileWithData(FileSourceTesting.newFakeData(1).build(), privateProject);
setUserWithValidPermission(file);
- wsTester
- .newGetRequest("api/sources", "lines")
+ tester.newRequest()
.setParam("uuid", file.uuid())
.execute()
.assertJson(getClass(), "display_deprecated_fields.json");
}
@Test
- public void use_period_date_if_new_line_not_yet_available_in_db() throws Exception {
+ public void use_period_date_if_new_line_not_yet_available_in_db() {
DbFileSources.Data.Builder dataBuilder = DbFileSources.Data.newBuilder();
dataBuilder.addLines(DbFileSources.Line.newBuilder().setLine(1).setScmDate(1000L).build());
dataBuilder.addLines(DbFileSources.Line.newBuilder().setLine(2).setScmDate(2000L).build());
ComponentDto file = insertFileWithData(dataBuilder.build(), project);
setUserWithValidPermission(file);
- wsTester
- .newGetRequest("api/sources", "lines")
+ tester.newRequest()
.setParam("uuid", file.uuid())
.execute()
.assertJson(getClass(), "generated_isNew.json");
}
@Test
- public void use_deprecated_overall_coverage_fields_if_exists() throws Exception {
+ public void use_deprecated_overall_coverage_fields_if_exists() {
DbFileSources.Data.Builder dataBuilder = DbFileSources.Data.newBuilder();
ComponentDto file = insertFileWithData(dataBuilder.addLines(newLineBuilder()
.setDeprecatedOverallLineHits(1)
.setDeprecatedItCoveredConditions(3)).build(), privateProject);
setUserWithValidPermission(file);
- wsTester
- .newGetRequest("api/sources", "lines")
+ tester.newRequest()
.setParam("uuid", file.uuid())
.execute()
.assertJson(getClass(), "convert_deprecated_data.json");
}
@Test
- public void use_deprecated_ut_coverage_fields_if_exists() throws Exception {
+ public void use_deprecated_ut_coverage_fields_if_exists() {
DbFileSources.Data.Builder dataBuilder = DbFileSources.Data.newBuilder();
ComponentDto file = insertFileWithData(dataBuilder.addLines(newLineBuilder()
.setDeprecatedUtLineHits(1)
.setDeprecatedItCoveredConditions(3)).build(), privateProject);
setUserWithValidPermission(file);
- TestRequest request = wsTester
- .newGetRequest("api/sources", "lines")
- .setParam("uuid", file.uuid());
-
- request.execute().assertJson(getClass(), "convert_deprecated_data.json");
+ tester.newRequest()
+ .setParam("uuid", file.uuid())
+ .execute()
+ .assertJson(getClass(), "convert_deprecated_data.json");
}
@Test
- public void use_deprecated_it_coverage_fields_if_exists() throws Exception {
+ public void use_deprecated_it_coverage_fields_if_exists() {
DbFileSources.Data.Builder dataBuilder = DbFileSources.Data.newBuilder();
ComponentDto file = insertFileWithData(dataBuilder.addLines(newLineBuilder()
.setDeprecatedItLineHits(1)
.setDeprecatedItCoveredConditions(3)).build(), privateProject);
setUserWithValidPermission(file);
- TestRequest request = wsTester
- .newGetRequest("api/sources", "lines")
- .setParam("uuid", file.uuid());
-
- request.execute().assertJson(getClass(), "convert_deprecated_data.json");
+ tester.newRequest()
+ .setParam("uuid", file.uuid())
+ .execute()
+ .assertJson(getClass(), "convert_deprecated_data.json");
}
@Test
- public void fail_if_branch_does_not_exist() throws Exception {
+ public void fail_if_branch_does_not_exist() {
ComponentDto project = db.components().insertPrivateProject();
ComponentDto file = db.components().insertComponent(newFileDto(project));
userSession.addProjectPermission(UserRole.USER, project);
expectedException.expect(NotFoundException.class);
expectedException.expectMessage(String.format("Component '%s' on branch '%s' not found", file.getKey(), "another_branch"));
- wsTester.newGetRequest("api/sources", "lines")
+ tester.newRequest()
.setParam("key", file.getKey())
.setParam("branch", "another_branch")
.execute();
}
@Test
- public void fail_when_uuid_and_branch_params_are_used_together() throws Exception {
+ public void fail_when_uuid_and_branch_params_are_used_together() {
ComponentDto project = db.components().insertPrivateProject();
ComponentDto file = db.components().insertComponent(newFileDto(project));
userSession.addProjectPermission(UserRole.USER, project);
expectedException.expect(IllegalArgumentException.class);
expectedException.expectMessage("Parameter 'uuid' cannot be used at the same time as 'branch' or 'pullRequest'");
- wsTester.newGetRequest("api/sources", "lines")
+ tester.newRequest()
.setParam("uuid", file.uuid())
.setParam("branch", "another_branch")
.execute();
}
@Test
- public void fail_when_using_branch_db_key() throws Exception {
+ public void fail_when_using_branch_db_key() {
ComponentDto project = db.components().insertMainBranch();
ComponentDto branch = db.components().insertProjectBranch(project);
userSession.addProjectPermission(UserRole.USER, project);
expectedException.expect(NotFoundException.class);
expectedException.expectMessage(format("Component key '%s' not found", branch.getDbKey()));
- wsTester.newGetRequest("api/sources", "lines")
+ tester.newRequest()
.setParam("key", branch.getDbKey())
.execute();
}
@Test
- public void fail_when_using_branch_uuid() throws Exception {
+ public void fail_when_using_branch_uuid() {
ComponentDto project = db.components().insertMainBranch();
ComponentDto branch = db.components().insertProjectBranch(project);
userSession.addProjectPermission(UserRole.USER, project);
expectedException.expect(NotFoundException.class);
expectedException.expectMessage(format("Component id '%s' not found", branch.uuid()));
- wsTester.newGetRequest("api/sources", "lines")
+ tester.newRequest()
.setParam("uuid", branch.uuid())
.execute();
}
@Test
- public void hide_scmAuthors_if_not_member_of_organization() throws Exception {
+ public void hide_scmAuthors_if_not_member_of_organization() {
OrganizationDto org = db.organizations().insert();
ComponentDto publicProject = db.components().insertPublicProject(org);
userSession.registerComponents(publicProject);
ComponentDto file = insertFileWithData(data, publicProject);
- wsTester.newGetRequest("api/sources", "lines")
+ tester.newRequest()
.setParam("uuid", file.uuid())
.execute()
.assertJson(getClass(), "hide_scmAuthors.json");
}
@Test
- public void show_scmAuthors_if_member_of_organization() throws Exception {
+ public void show_scmAuthors_if_member_of_organization() {
OrganizationDto org = db.organizations().insert();
ComponentDto publicProject = db.components().insertPublicProject(org);
UserDto user = db.users().insertUser();
ComponentDto file = insertFileWithData(data, publicProject);
- wsTester.newGetRequest("api/sources", "lines")
+ tester.newRequest()
.setParam("uuid", file.uuid())
.execute()
.assertJson(getClass(), "show_scmAuthors.json");
import org.sonar.server.source.HtmlSourceDecorator;
import org.sonar.server.source.SourceService;
import org.sonar.server.tester.UserSessionRule;
-import org.sonar.server.ws.WsTester;
+import org.sonar.server.ws.WsActionTester;
import static java.lang.String.format;
@Rule
public UserSessionRule userSessionRule = UserSessionRule.standalone();
- private WsTester tester;
private DbClient dbClient = dbTester.getDbClient();
private DbSession dbSession = dbTester.getSession();
private ComponentDto project;
private ComponentDto file;
+ private ScmAction underTest = new ScmAction(dbClient, new SourceService(dbTester.getDbClient(), new HtmlSourceDecorator()),
+ userSessionRule, TestComponentFinder.from(dbTester));
+ private WsActionTester tester = new WsActionTester(underTest);
@Before
public void setUp() {
- tester = new WsTester(
- new SourcesWs(new ScmAction(dbClient, new SourceService(dbTester.getDbClient(), new HtmlSourceDecorator()), userSessionRule, TestComponentFinder.from(dbTester))));
-
project = ComponentTesting.newPrivateProjectDto(dbTester.organizations().insert(), PROJECT_UUID);
file = ComponentTesting.newFileDto(project, null, FILE_UUID).setDbKey(FILE_KEY);
dbClient.componentDao().insert(dbTester.getSession(), project, file);
}
@Test
- public void show_scm() throws Exception {
+ public void show_scm() {
userSessionRule.addProjectPermission(UserRole.CODEVIEWER, project, file);
dbTester.getDbClient().fileSourceDao().insert(dbSession, new FileSourceDto()
newSourceLine("julien", "123-456-789", DateUtils.parseDateTime("2015-03-30T12:34:56+0000"), 1)).build()));
dbSession.commit();
- WsTester.TestRequest request = tester.newGetRequest("api/sources", "scm").setParam("key", FILE_KEY);
- request.execute().assertJson(getClass(), "show_scm.json");
+ tester.newRequest()
+ .setParam("key", FILE_KEY)
+ .execute()
+ .assertJson(getClass(), "show_scm.json");
}
@Test
- public void show_scm_from_given_range_lines() throws Exception {
+ public void show_scm_from_given_range_lines() {
userSessionRule.addProjectPermission(UserRole.CODEVIEWER, project, file);
dbTester.getDbClient().fileSourceDao().insert(dbSession, new FileSourceDto()
.build()));
dbSession.commit();
- WsTester.TestRequest request = tester.newGetRequest("api/sources", "scm").setParam("key", FILE_KEY).setParam("from", "2").setParam("to", "3");
- request.execute().assertJson(getClass(), "show_scm_from_given_range_lines.json");
+ tester.newRequest()
+ .setParam("key", FILE_KEY)
+ .setParam("from", "2")
+ .setParam("to", "3")
+ .execute()
+ .assertJson(getClass(), "show_scm_from_given_range_lines.json");
}
@Test
- public void not_group_lines_by_commit() throws Exception {
+ public void not_group_lines_by_commit() {
userSessionRule.addProjectPermission(UserRole.CODEVIEWER, project, file);
// lines 1 and 2 are the same commit, but not 3 (different date)
.build()));
dbSession.commit();
- WsTester.TestRequest request = tester.newGetRequest("api/sources", "scm").setParam("key", FILE_KEY).setParam("commits_by_line",
- "true");
- request.execute().assertJson(getClass(), "not_group_lines_by_commit.json");
+ tester.newRequest()
+ .setParam("key", FILE_KEY)
+ .setParam("commits_by_line","true")
+ .execute()
+ .assertJson(getClass(), "not_group_lines_by_commit.json");
}
@Test
- public void group_lines_by_commit() throws Exception {
+ public void group_lines_by_commit() {
userSessionRule.addProjectPermission(UserRole.CODEVIEWER, project, file);
// lines 1 and 2 are the same commit, but not 3 (different date)
.build()));
dbSession.commit();
- WsTester.TestRequest request = tester.newGetRequest("api/sources", "scm").setParam("key", FILE_KEY).setParam("commits_by_line",
- "false");
- request.execute().assertJson(getClass(), "group_lines_by_commit.json");
+ tester.newRequest()
+ .setParam("key", FILE_KEY)
+ .setParam("commits_by_line","false")
+ .execute()
+ .assertJson(getClass(), "group_lines_by_commit.json");
}
@Test
- public void accept_negative_value_in_from_parameter() throws Exception {
+ public void accept_negative_value_in_from_parameter() {
userSessionRule.addProjectPermission(UserRole.CODEVIEWER, project, file);
dbTester.getDbClient().fileSourceDao().insert(dbSession, new FileSourceDto()
.build()));
dbSession.commit();
- WsTester.TestRequest request = tester.newGetRequest("api/sources", "scm").setParam("key", FILE_KEY).setParam("from",
- "-2").setParam("to", "3");
- request.execute().assertJson(getClass(), "accept_negative_value_in_from_parameter.json");
+ tester.newRequest()
+ .setParam("key", FILE_KEY)
+ .setParam("from","-2")
+ .setParam("to", "3")
+ .execute()
+ .assertJson(getClass(), "accept_negative_value_in_from_parameter.json");
}
@Test
- public void return_empty_value_when_no_scm() throws Exception {
+ public void return_empty_value_when_no_scm() {
userSessionRule.addProjectPermission(UserRole.CODEVIEWER, project, file);
dbTester.getDbClient().fileSourceDao().insert(dbSession, new FileSourceDto()
.setSourceData(DbFileSources.Data.newBuilder().build()));
dbSession.commit();
- WsTester.TestRequest request = tester.newGetRequest("api/sources", "scm").setParam("key", FILE_KEY);
- request.execute().assertJson(getClass(), "return_empty_value_when_no_scm.json");
+ tester.newRequest()
+ .setParam("key", FILE_KEY)
+ .execute()
+ .assertJson(getClass(), "return_empty_value_when_no_scm.json");
}
@Test(expected = ForbiddenException.class)
- public void fail_without_code_viewer_permission() throws Exception {
+ public void fail_without_code_viewer_permission() {
userSessionRule.addProjectPermission(UserRole.USER, project, file);
- WsTester.TestRequest request = tester.newGetRequest("api/sources", "scm").setParam("key", FILE_KEY);
- request.execute();
+ tester.newRequest()
+ .setParam("key", FILE_KEY)
+ .execute();
}
@Test
- public void fail_when_using_branch_db_key() throws Exception {
+ public void fail_when_using_branch_db_key() {
ComponentDto project = dbTester.components().insertMainBranch();
ComponentDto branch = dbTester.components().insertProjectBranch(project);
userSessionRule.addProjectPermission(UserRole.CODEVIEWER, project);
expectedException.expect(NotFoundException.class);
expectedException.expectMessage(format("Component key '%s' not found", branch.getDbKey()));
- tester.newGetRequest("api/sources", "scm")
+ tester.newRequest()
.setParam("key", branch.getDbKey())
.execute();
}
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
import org.sonar.api.resources.Qualifiers;
import org.sonar.api.web.UserRole;
import org.sonar.db.DbClient;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.source.SourceService;
import org.sonar.server.tester.UserSessionRule;
-import org.sonar.server.ws.WsTester;
+import org.sonar.server.ws.WsActionTester;
import static com.google.common.collect.Lists.newArrayList;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-@RunWith(MockitoJUnitRunner.class)
public class ShowActionTest {
@Rule
public UserSessionRule userSessionRule = UserSessionRule.standalone();
- SourceService sourceService = mock(SourceService.class);
-
- WsTester tester;
-
- @Mock
- DbClient dbClient;
-
- @Mock
- DbSession session;
-
- @Mock
- ComponentDao componentDao;
-
- ComponentDto project = ComponentTesting.newPrivateProjectDto(OrganizationTesting.newOrganizationDto());
- ComponentDto file = ComponentTesting.newFileDto(project, null);
+ private SourceService sourceService = mock(SourceService.class);
+ private DbClient dbClient = mock(DbClient.class);
+ private DbSession session = mock(DbSession.class);
+ private ComponentDao componentDao = mock(ComponentDao.class);
+ private ComponentDto project = ComponentTesting.newPrivateProjectDto(OrganizationTesting.newOrganizationDto());
+ private ComponentDto file = ComponentTesting.newFileDto(project, null);
+ private ShowAction underTest = new ShowAction(sourceService, dbClient, userSessionRule,
+ new ComponentFinder(dbClient, new ResourceTypesRule().setRootQualifiers(Qualifiers.PROJECT)));
+ private WsActionTester tester = new WsActionTester(underTest);
@Before
public void setUp() {
when(dbClient.componentDao()).thenReturn(componentDao);
when(dbClient.openSession(false)).thenReturn(session);
- tester = new WsTester(new SourcesWs(new ShowAction(sourceService, dbClient, userSessionRule,
- new ComponentFinder(dbClient, new ResourceTypesRule().setRootQualifiers(Qualifiers.PROJECT)))));
}
@Test
- public void show_source() throws Exception {
+ public void show_source() {
String fileKey = "src/Foo.java";
userSessionRule.addProjectPermission(UserRole.CODEVIEWER, project);
when(componentDao.selectByKey(session, fileKey)).thenReturn(Optional.of(file));
"public class <span class=\"sym-31 sym\">HelloWorld</span> {",
"}")));
- WsTester.TestRequest request = tester.newGetRequest("api/sources", "show").setParam("key", fileKey);
- request.execute().assertJson(getClass(), "show_source.json");
+ tester.newRequest()
+ .setParam("key", fileKey)
+ .execute()
+ .assertJson(getClass(), "show_source.json");
}
@Test
- public void show_source_with_from_and_to_params() throws Exception {
+ public void show_source_with_from_and_to_params() {
String fileKey = "src/Foo.java";
userSessionRule.addProjectPermission(UserRole.CODEVIEWER, project);
when(componentDao.selectByKey(session, fileKey)).thenReturn(Optional.of(file));
" */",
"",
"public class <span class=\"sym-31 sym\">HelloWorld</span> {")));
- WsTester.TestRequest request = tester
- .newGetRequest("api/sources", "show")
+ tester.newRequest()
.setParam("key", fileKey)
.setParam("from", "3")
- .setParam("to", "5");
- request.execute().assertJson(getClass(), "show_source_with_params_from_and_to.json");
+ .setParam("to", "5")
+ .execute()
+ .assertJson(getClass(), "show_source_with_params_from_and_to.json");
}
@Test
- public void show_source_accept_from_less_than_one() throws Exception {
+ public void show_source_accept_from_less_than_one() {
String fileKey = "src/Foo.java";
userSessionRule.addProjectPermission(UserRole.CODEVIEWER, project);
when(componentDao.selectByKey(session, fileKey)).thenReturn(Optional.of(file));
" */",
"",
"public class <span class=\"sym-31 sym\">HelloWorld</span> {")));
- WsTester.TestRequest request = tester
- .newGetRequest("api/sources", "show")
+ tester.newRequest()
.setParam("key", fileKey)
.setParam("from", "0")
- .setParam("to", "5");
- request.execute();
+ .setParam("to", "5")
+ .execute();
verify(sourceService).getLinesAsHtml(session, file.uuid(), 1, 5);
}
@Test(expected = ForbiddenException.class)
- public void require_code_viewer() throws Exception {
+ public void require_code_viewer() {
String fileKey = "src/Foo.java";
when(componentDao.selectByKey(session, fileKey)).thenReturn(Optional.of(file));
- tester.newGetRequest("api/sources", "show").setParam("key", fileKey).execute();
+ tester.newRequest().setParam("key", fileKey).execute();
}
}
import org.junit.Test;
import org.sonar.api.server.ws.WebService;
import org.sonar.server.tester.UserSessionRule;
-import org.sonar.server.ws.WsTester;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
})
.toArray(SourcesWsAction[]::new);
- WsTester underTest = new WsTester(new SourcesWs(actions));
+ SourcesWs underTest = new SourcesWs(actions);
+ WebService.Context context = new WebService.Context();
- WebService.Controller controller = underTest.controller("api/sources");
+ underTest.define(context);
+
+ WebService.Controller controller = context.controller("api/sources");
assertThat(controller).isNotNull();
assertThat(controller.since()).isEqualTo("4.2");
assertThat(controller.description()).isNotEmpty();
*/
package org.sonar.server.updatecenter.ws;
-import org.junit.Before;
import org.junit.Test;
+import org.sonar.api.server.ws.Request;
+import org.sonar.api.server.ws.Response;
import org.sonar.api.server.ws.WebService;
-import org.sonar.server.platform.ServerFileSystem;
-import org.sonar.server.ws.WsTester;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
public class UpdateCenterWsTest {
+ private UpdateCenterWs underTest = new UpdateCenterWs(new UpdateCenterWsAction() {
+ @Override
+ public void define(WebService.NewController context) {
+ context.createAction("foo").setHandler(this);
+ }
- WsTester tester;
+ @Override
+ public void handle(Request request, Response response) {
- @Before
- public void setUp() {
- tester = new WsTester(new UpdateCenterWs(new UploadAction(null, mock(ServerFileSystem.class))));
- }
+ }
+ });
@Test
public void define_controller() {
- WebService.Controller controller = tester.controller("api/updatecenter");
+ WebService.Context context = new WebService.Context();
+
+ underTest.define(context);
+
+ WebService.Controller controller = context.controller("api/updatecenter");
assertThat(controller).isNotNull();
assertThat(controller.since()).isEqualTo("2.10");
assertThat(controller.description()).isNotEmpty();
assertThat(controller.actions()).hasSize(1);
}
-
- @Test
- public void define_upload_action() {
- WebService.Controller controller = tester.controller("api/updatecenter");
-
- WebService.Action action = controller.action("upload");
- assertThat(action).isNotNull();
- assertThat(action.handler()).isNotNull();
- assertThat(action.isInternal()).isTrue();
- assertThat(action.isPost()).isTrue();
- assertThat(action.params()).hasSize(1);
- }
}
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.rules.TemporaryFolder;
+import org.sonar.api.server.ws.WebService;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.platform.ServerFileSystem;
import org.sonar.server.tester.UserSessionRule;
wsTester = new WsActionTester(new UploadAction(userSession, fileSystem));
}
+ @Test
+ public void define_upload_action() {
+ WebService.Action action = wsTester.getDef();
+
+ assertThat(action).isNotNull();
+ assertThat(action.key()).isEqualTo("upload");
+ assertThat(action.handler()).isNotNull();
+ assertThat(action.isInternal()).isTrue();
+ assertThat(action.isPost()).isTrue();
+ assertThat(action.params()).hasSize(1);
+ }
+
@Test
public void upload_plugin() throws Exception {
logInAsSystemAdministrator();
import org.junit.Test;
import org.sonar.api.server.ws.WebService;
-import org.sonar.server.ws.WsTester;
+import org.sonar.server.ws.RemovedWebServiceHandler;
import static org.assertj.core.api.Assertions.assertThat;
public class UserPropertiesWsTest {
- WsTester tester = new WsTester(new UserPropertiesWs());
+ private UserPropertiesWs underTest = new UserPropertiesWs();
@Test
public void define_ws() {
- WebService.Controller controller = tester.controller("api/user_properties");
+ WebService.Context context = new WebService.Context();
+
+ underTest.define(context);
+
+ WebService.Controller controller = context.controller("api/user_properties");
assertThat(controller).isNotNull();
assertThat(controller.description()).isNotEmpty();
assertThat(controller.actions()).hasSize(1);
+
+ WebService.Action index = controller.action("index");
+ assertThat(index.since()).isEqualTo("2.6");
+ assertThat(index.deprecatedSince()).isEqualTo("6.3");
+ assertThat(index.handler()).isSameAs(RemovedWebServiceHandler.INSTANCE);
+ assertThat(index.responseExample()).isEqualTo(RemovedWebServiceHandler.INSTANCE.getResponseExample());
}
}
package org.sonar.server.usergroups.ws;
import org.apache.commons.lang.StringUtils;
-import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
+import org.sonar.api.server.ws.WebService;
import org.sonar.api.utils.System2;
import org.sonar.db.DbTester;
import org.sonar.db.organization.OrganizationDto;
import org.sonar.server.organization.TestDefaultOrganizationProvider;
import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.usergroups.DefaultGroupFinder;
-import org.sonar.server.ws.WsTester;
+import org.sonar.server.ws.WsActionTester;
import static org.assertj.core.api.Assertions.assertThat;
import static org.sonar.db.permission.OrganizationPermission.ADMINISTER;
public ExpectedException expectedException = ExpectedException.none();
private TestDefaultOrganizationProvider defaultOrganizationProvider = TestDefaultOrganizationProvider.from(db);
- private WsTester ws;
+ private CreateAction underTest = new CreateAction(db.getDbClient(), userSession, newGroupWsSupport());
+ private WsActionTester tester = new WsActionTester(underTest);
- @Before
- public void setUp() {
- ws = new WsTester(new UserGroupsWs(new CreateAction(db.getDbClient(), userSession, newGroupWsSupport())));
+ @Test
+ public void define_create_action() {
+ WebService.Action action = tester.getDef();
+ assertThat(action).isNotNull();
+ assertThat(action.key()).isEqualTo("create");
+ assertThat(action.isPost()).isTrue();
+ assertThat(action.responseExampleAsString()).isNotEmpty();
+ assertThat(action.params()).hasSize(3);
}
@Test
- public void create_group_on_default_organization() throws Exception {
+ public void create_group_on_default_organization() {
loginAsAdminOnDefaultOrganization();
- newRequest()
+ tester.newRequest()
.setParam("name", "some-product-bu")
.setParam("description", "Business Unit for Some Awesome Product")
.execute()
}
@Test
- public void create_group_on_specific_organization() throws Exception {
+ public void create_group_on_specific_organization() {
OrganizationDto org = db.organizations().insert();
loginAsAdmin(org);
- newRequest()
+ tester.newRequest()
.setParam("organization", org.getKey())
.setParam("name", "some-product-bu")
.setParam("description", "Business Unit for Some Awesome Product")
}
@Test
- public void return_default_field() throws Exception {
+ public void return_default_field() {
loginAsAdminOnDefaultOrganization();
- newRequest()
+ tester.newRequest()
.setParam("name", "some-product-bu")
.setParam("description", "Business Unit for Some Awesome Product")
.execute()
}
@Test
- public void fail_if_not_administrator() throws Exception {
+ public void fail_if_not_administrator() {
userSession.logIn("not-admin");
expectedException.expect(ForbiddenException.class);
- newRequest()
+ tester.newRequest()
.setParam("name", "some-product-bu")
.setParam("description", "Business Unit for Some Awesome Product")
.execute();
}
@Test
- public void fail_if_administrator_of_another_organization() throws Exception {
+ public void fail_if_administrator_of_another_organization() {
OrganizationDto org1 = db.organizations().insert();
OrganizationDto org2 = db.organizations().insert();
loginAsAdmin(org2);
expectedException.expect(ForbiddenException.class);
- newRequest()
+ tester.newRequest()
.setParam("organization", org1.getKey())
.setParam("name", "some-product-bu")
.setParam("description", "Business Unit for Some Awesome Product")
}
@Test(expected = IllegalArgumentException.class)
- public void fail_if_name_is_too_short() throws Exception {
+ public void fail_if_name_is_too_short() {
loginAsAdminOnDefaultOrganization();
- newRequest()
+ tester.newRequest()
.setParam("name", "")
.execute();
}
@Test(expected = IllegalArgumentException.class)
- public void fail_if_name_is_too_long() throws Exception {
+ public void fail_if_name_is_too_long() {
loginAsAdminOnDefaultOrganization();
- newRequest()
+ tester.newRequest()
.setParam("name", StringUtils.repeat("a", 255 + 1))
.execute();
}
@Test(expected = IllegalArgumentException.class)
- public void fail_if_name_is_anyone() throws Exception {
+ public void fail_if_name_is_anyone() {
loginAsAdminOnDefaultOrganization();
- newRequest()
+ tester.newRequest()
.setParam("name", "AnYoNe")
.execute();
}
@Test
- public void fail_if_group_with_same_name_already_exists() throws Exception {
+ public void fail_if_group_with_same_name_already_exists() {
GroupDto group = db.users().insertGroup();
loginAsAdminOnDefaultOrganization();
expectedException.expect(ServerException.class);
expectedException.expectMessage("Group '" + group.getName() + "' already exists");
- newRequest()
+ tester.newRequest()
.setParam("name", group.getName())
.execute();
}
@Test
- public void fail_if_group_with_same_name_already_exists_in_the_organization() throws Exception {
+ public void fail_if_group_with_same_name_already_exists_in_the_organization() {
OrganizationDto org = db.organizations().insert();
GroupDto group = db.users().insertGroup(org, "the-group");
loginAsAdmin(org);
expectedException.expect(ServerException.class);
expectedException.expectMessage("Group '" + group.getName() + "' already exists");
- newRequest()
+ tester.newRequest()
.setParam("organization", org.getKey())
.setParam("name", group.getName())
.execute();
}
@Test
- public void add_group_with_a_name_that_already_exists_in_another_organization() throws Exception {
+ public void add_group_with_a_name_that_already_exists_in_another_organization() {
String name = "the-group";
OrganizationDto org1 = db.organizations().insert();
OrganizationDto org2 = db.organizations().insert();
GroupDto group = db.users().insertGroup(org1, name);
loginAsAdmin(org2);
- newRequest()
+ tester.newRequest()
.setParam("organization", org2.getKey())
.setParam("name", name)
.execute()
}
@Test(expected = IllegalArgumentException.class)
- public void fail_if_description_is_too_long() throws Exception {
+ public void fail_if_description_is_too_long() {
loginAsAdminOnDefaultOrganization();
- newRequest()
+ tester.newRequest()
.setParam("name", "long-desc")
.setParam("description", StringUtils.repeat("a", 1_000))
.execute();
}
- private WsTester.TestRequest newRequest() {
- return ws.newPostRequest("api/user_groups", "create");
- }
-
private void loginAsAdminOnDefaultOrganization() {
loginAsAdmin(db.getDefaultOrganization());
}
private WsActionTester ws = new WsActionTester(new SearchAction(db.getDbClient(), userSession, newGroupWsSupport(), new DefaultGroupFinder(db.getDbClient())));
+
+ @Test
+ public void define_search_action() {
+ WebService.Action action = ws.getDef();
+ assertThat(action).isNotNull();
+ assertThat(action.key()).isEqualTo("search");
+ assertThat(action.responseExampleAsString()).isNotEmpty();
+ assertThat(action.params()).hasSize(5);
+ }
+
@Test
public void search_without_parameters() {
insertDefaultGroup(db.getDefaultOrganization(), "users", 0);
*/
package org.sonar.server.usergroups.ws;
-import org.junit.Before;
-import org.junit.Rule;
import org.junit.Test;
+import org.sonar.api.server.ws.Request;
+import org.sonar.api.server.ws.Response;
import org.sonar.api.server.ws.WebService;
-import org.sonar.db.DbClient;
-import org.sonar.server.tester.UserSessionRule;
-import org.sonar.server.user.UserSession;
-import org.sonar.server.usergroups.DefaultGroupFinder;
-import org.sonar.server.ws.WsTester;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
public class UserGroupsWsTest {
- @Rule
- public UserSessionRule userSessionRule = UserSessionRule.standalone();
+ private UserGroupsWs underTest = new UserGroupsWs(new UserGroupsWsAction() {
+ @Override
+ public void define(WebService.NewController context) {
+ context.createAction("foo").setHandler(this);
+ }
- WebService.Controller controller;
+ @Override
+ public void handle(Request request, Response response) {
- @Before
- public void setUp() {
- GroupWsSupport wsSupport = mock(GroupWsSupport.class);
- WsTester tester = new WsTester(new UserGroupsWs(
- new SearchAction(mock(DbClient.class), mock(UserSession.class), wsSupport, mock(DefaultGroupFinder.class)),
- new CreateAction(mock(DbClient.class), mock(UserSession.class), wsSupport)));
- controller = tester.controller("api/user_groups");
- }
+ }
+ });
@Test
public void define_controller() {
+ WebService.Context context = new WebService.Context();
+
+ underTest.define(context);
+
+ WebService.Controller controller = context.controller("api/user_groups");
assertThat(controller).isNotNull();
assertThat(controller.description()).isNotEmpty();
assertThat(controller.since()).isEqualTo("5.2");
- assertThat(controller.actions()).hasSize(2);
- }
-
- @Test
- public void define_search_action() {
- WebService.Action action = controller.action("search");
- assertThat(action).isNotNull();
- assertThat(action.responseExampleAsString()).isNotEmpty();
- assertThat(action.params()).hasSize(5);
- }
-
- @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);
+ assertThat(controller.actions()).hasSize(1);
}
}
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
+import org.sonar.api.server.ws.WebService;
import org.sonar.api.utils.System2;
import org.sonar.db.DbTester;
import org.sonar.db.user.UserDto;
when(tokenGenerator.hash(anyString())).thenReturn("987654321");
}
+ @Test
+ public void generate_action() {
+ WebService.Action action = ws.getDef();
+
+ assertThat(action.key()).isEqualTo("generate");
+ assertThat(action.since()).isEqualTo("5.3");
+ assertThat(action.responseExampleAsString()).isNotEmpty();
+ assertThat(action.isPost()).isTrue();
+ assertThat(action.param("login").isRequired()).isFalse();
+ assertThat(action.param("name").isRequired()).isTrue();
+ }
+
@Test
public void json_example() {
UserDto user1 = db.users().insertUser(u -> u.setLogin("grace.hopper"));
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
+import org.sonar.api.server.ws.WebService;
import org.sonar.api.utils.System2;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
private DbSession dbSession = db.getSession();
private WsActionTester ws = new WsActionTester(new RevokeAction(dbClient, new UserTokenSupport(db.getDbClient(), userSession)));
+ @Test
+ public void revoke_action() {
+ WebService.Action action = ws.getDef();
+
+ assertThat(action).isNotNull();
+ assertThat(action.key()).isEqualTo("revoke");
+ assertThat(action.since()).isEqualTo("5.3");
+ assertThat(action.isPost()).isTrue();
+ assertThat(action.param("login").isRequired()).isFalse();
+ assertThat(action.param("name").isRequired()).isTrue();
+ }
+
@Test
public void delete_token_in_db() {
logInAsSystemAdministrator();
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
+import org.sonar.api.server.ws.WebService;
import org.sonar.api.utils.System2;
import org.sonar.db.DbClient;
import org.sonar.db.DbTester;
private DbClient dbClient = db.getDbClient();
private WsActionTester ws = new WsActionTester(new SearchAction(dbClient, new UserTokenSupport(db.getDbClient(), userSession)));
+ @Test
+ public void search_action() {
+ WebService.Action action = ws.getDef();
+
+ assertThat(action).isNotNull();
+ assertThat(action.key()).isEqualTo("search");
+ assertThat(action.since()).isEqualTo("5.3");
+ assertThat(action.isPost()).isFalse();
+ assertThat(action.param("login").isRequired()).isFalse();
+ }
+
@Test
public void search_json_example() {
UserDto user1 = db.users().insertUser(u -> u.setLogin("grace.hopper"));
*/
package org.sonar.server.usertoken.ws;
-import org.junit.Before;
import org.junit.Test;
+import org.sonar.api.server.ws.Request;
+import org.sonar.api.server.ws.Response;
import org.sonar.api.server.ws.WebService;
-import org.sonar.api.utils.System2;
-import org.sonar.db.DbClient;
-import org.sonar.server.usertoken.TokenGenerator;
-import org.sonar.server.ws.WsTester;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
public class UserTokensWsTest {
- static final String CONTROLLER_KEY = "api/user_tokens";
- WsTester ws;
+ private UserTokensWs underTest = new UserTokensWs(new UserTokensWsAction() {
+ @Override
+ public void define(WebService.NewController context) {
+ context.createAction("foo").setHandler(this);
+ }
- @Before
- public void setUp() {
- DbClient dbClient = mock(DbClient.class);
- System2 system = mock(System2.class);
- TokenGenerator tokenGenerator = mock(TokenGenerator.class);
- UserTokenSupport userTokenSupport = mock(UserTokenSupport.class);
+ @Override
+ public void handle(Request request, Response response) {
- ws = new WsTester(new UserTokensWs(
- new GenerateAction(dbClient, system, tokenGenerator, userTokenSupport),
- new RevokeAction(dbClient, userTokenSupport),
- new SearchAction(dbClient, userTokenSupport)));
- }
-
- @Test
- public void generate_action() {
- WebService.Action action = ws.action(CONTROLLER_KEY, "generate");
-
- assertThat(action).isNotNull();
- assertThat(action.since()).isEqualTo("5.3");
- assertThat(action.responseExampleAsString()).isNotEmpty();
- assertThat(action.isPost()).isTrue();
- assertThat(action.param("login").isRequired()).isFalse();
- assertThat(action.param("name").isRequired()).isTrue();
- }
+ }
+ });
@Test
- public void revoke_action() {
- WebService.Action action = ws.action(CONTROLLER_KEY, "revoke");
-
- assertThat(action).isNotNull();
- assertThat(action.since()).isEqualTo("5.3");
- assertThat(action.isPost()).isTrue();
- assertThat(action.param("login").isRequired()).isFalse();
- assertThat(action.param("name").isRequired()).isTrue();
- }
+ public void is_defined() {
+ WebService.Context context = new WebService.Context();
- @Test
- public void search_action() {
- WebService.Action action = ws.action(CONTROLLER_KEY, "search");
+ underTest.define(context);
- assertThat(action).isNotNull();
- assertThat(action.since()).isEqualTo("5.3");
- assertThat(action.isPost()).isFalse();
- assertThat(action.param("login").isRequired()).isFalse();
+ WebService.Controller controller = context.controller("api/user_tokens");
+ assertThat(controller).isNotNull();
+ assertThat(controller.since()).isEqualTo("5.3");
+ assertThat(controller.description()).isNotEmpty();
+ assertThat(controller.actions()).hasSize(1);
}
}
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2019 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+package org.sonar.server.ws.ws;
+
+import java.util.Arrays;
+import org.junit.Before;
+import org.junit.Test;
+import org.sonar.api.server.ws.WebService;
+import org.sonar.server.ws.TestRequest;
+
+import static org.sonar.test.JsonAssert.assertJson;
+
+public class ListActionTest {
+ private WebService.Context context = new WebService.Context();
+ private ListAction underTest = new ListAction();
+ private WebService.Action action;
+
+ @Before
+ public void setUp() throws Exception {
+ WebService.NewController newController = context.createController("api/webservices")
+ .setDescription("Get information on the web api supported on this instance.")
+ .setSince("4.2");
+
+ for (WebServicesWsAction wsWsAction : Arrays.asList(underTest, new ResponseExampleAction())) {
+ wsWsAction.define(newController);
+ wsWsAction.setContext(context);
+ }
+
+ newController.done();
+ action = context.controller("api/webservices").action("list");
+ }
+
+ @Test
+ public void list() {
+ new MetricWs().define(context);
+
+ String response = newRequest().execute().getInput();
+
+ assertJson(response).withStrictArrayOrder().isSimilarTo(getClass().getResource("list-example.json"));
+ }
+
+ @Test
+ public void list_including_internals() {
+ MetricWs metricWs = new MetricWs();
+ metricWs.define(context);
+
+ newRequest()
+ .setParam("include_internals", "true")
+ .execute()
+ .assertJson(getClass(), "list_including_internals.json");
+ }
+
+ public TestRequest newRequest() {
+ TestRequest request = new TestRequest();
+ request.setAction(action);
+ return request;
+ }
+
+}
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2019 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+package org.sonar.server.ws.ws;
+
+import com.google.common.io.Resources;
+import org.sonar.api.server.ws.Change;
+import org.sonar.api.server.ws.WebService;
+
+class MetricWs implements WebService {
+ @Override
+ public void define(Context context) {
+ NewController newController = context
+ .createController("api/metric")
+ .setDescription("Metrics")
+ .setSince("3.2");
+
+ // action with default values
+ newController.createAction("show")
+ .setSince("3.2")
+ .setDescription("Show Description")
+ .setResponseExample(getClass().getResource("web-services-ws-test.txt"))
+ .setHandler((request, response) -> {
+ });
+
+ // action with a lot of overridden values
+ NewAction create = newController.createAction("create")
+ .setPost(true)
+ .setDescription("Create metric")
+ .setSince("4.1")
+ .setDeprecatedSince("5.3")
+ .setResponseExample(Resources.getResource(getClass(), "ListActionTest/metrics_example.json"))
+ .setChangelog(
+ new Change("4.5", "Deprecate database ID in response"),
+ new Change("6.0", "Remove database ID from response"),
+ new Change("6.6", "Requires 'Administer System' permission instead of 'Administer Quality Profiles'"))
+ .setHandler((request, response) -> {
+ });
+
+ create
+ .createParam("severity")
+ .setDescription("Severity")
+ .setSince("4.4")
+ .setDeprecatedSince("5.2")
+ .setDeprecatedKey("old_severity", "4.6")
+ .setRequired(false)
+ .setPossibleValues("BLOCKER", "INFO")
+ .setExampleValue("INFO")
+ .setDefaultValue("BLOCKER");
+ create.createParam("name");
+ create.createParam("internal").setInternal(true);
+
+ create
+ .createParam("constrained_string_param")
+ .setMaximumLength(64)
+ .setMinimumLength(3);
+
+ create
+ .createParam("constrained_numeric_param")
+ .setMaximumValue(12);
+
+ newController.createAction("internal_action")
+ .setDescription("Internal Action Description")
+ .setResponseExample(getClass().getResource("web-services-ws-test.txt"))
+ .setSince("5.3")
+ .setInternal(true)
+ .setHandler((request, response) -> {
+ });
+
+ newController.done();
+ }
+}
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2019 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+package org.sonar.server.ws.ws;
+
+import com.google.common.collect.Iterables;
+import org.junit.Before;
+import org.junit.Test;
+import org.sonar.api.server.ws.WebService;
+import org.sonar.server.ws.TestRequest;
+
+public class ResponseExampleActionTest {
+ private WebService.Context context = new WebService.Context();
+ private ResponseExampleAction underTest = new ResponseExampleAction();
+ private WebService.Action action;
+
+ @Before
+ public void setUp() throws Exception {
+ WebService.NewController newController = context.createController("api/ws");
+ underTest.define(newController);
+ newController.done();
+ action = Iterables.get(context.controller("api/ws").actions(), 0);
+ underTest.setContext(context);
+ }
+
+ @Test
+ public void response_example() {
+ MetricWs metricWs = new MetricWs();
+ metricWs.define(context);
+
+ newRequest()
+ .setParam("controller", "api/metric")
+ .setParam("action", "create")
+ .execute()
+ .assertJson(getClass(), "response_example.json");
+ }
+
+ public TestRequest newRequest() {
+ TestRequest request = new TestRequest();
+ request.setAction(action);
+ return request;
+ }
+
+}
*/
package org.sonar.server.ws.ws;
-import com.google.common.io.Resources;
+import java.util.Arrays;
import org.junit.Test;
-import org.sonar.api.server.ws.Change;
+import org.sonar.api.server.ws.Request;
+import org.sonar.api.server.ws.Response;
import org.sonar.api.server.ws.WebService;
-import org.sonar.server.ws.WsTester;
-import static java.util.Arrays.asList;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.sonar.test.JsonAssert.assertJson;
public class WebServicesWsTest {
- private WebServicesWs underTest = new WebServicesWs(asList(new ListAction(), new ResponseExampleAction()));
+ private DummyWebServicesWsAction dummyWebServicesWsAction = new DummyWebServicesWsAction();
+ private WebServicesWs underTest = new WebServicesWs(Arrays.asList(dummyWebServicesWsAction));
@Test
public void define_ws() {
- WsTester tester = new WsTester(underTest);
- WebService.Controller controller = tester.controller("api/webservices");
+ WebService.Context context = new WebService.Context();
+
+ underTest.define(context);
+
+ WebService.Controller controller = context.controller("api/webservices");
assertThat(controller).isNotNull();
assertThat(controller.path()).isEqualTo("api/webservices");
assertThat(controller.since()).isEqualTo("4.2");
assertThat(controller.description()).isNotEmpty();
- assertThat(controller.actions()).hasSize(2);
-
- WebService.Action index = controller.action("list");
- assertThat(index).isNotNull();
- assertThat(index.key()).isEqualTo("list");
- assertThat(index.handler()).isNotNull();
- assertThat(index.since()).isEqualTo("4.2");
- assertThat(index.isPost()).isFalse();
- assertThat(index.isInternal()).isFalse();
-
- assertThat(controller.action("response_example")).isNotNull();
- }
+ assertThat(controller.actions()).hasSize(1);
- @Test
- public void list() throws Exception {
- WsTester tester = new WsTester(underTest, new MetricWs());
-
- String response = tester.newGetRequest("api/webservices", "list").execute().outputAsString();
-
- assertJson(response).withStrictArrayOrder().isSimilarTo(getClass().getResource("list-example.json"));
+ assertThat(dummyWebServicesWsAction.context).isNotNull();
}
- @Test
- public void list_including_internals() throws Exception {
- WsTester tester = new WsTester(underTest, new MetricWs());
- tester.newGetRequest("api/webservices", "list")
- .setParam("include_internals", "true")
- .execute()
- .assertJson(getClass(), "list_including_internals.json");
- }
+ private static class DummyWebServicesWsAction implements WebServicesWsAction {
- @Test
- public void response_example() throws Exception {
- WsTester tester = new WsTester(underTest, new MetricWs());
- tester
- .newGetRequest("api/webservices", "response_example")
- .setParam("controller", "api/metric")
- .setParam("action", "create")
- .execute().assertJson(getClass(), "response_example.json");
- }
+ private WebService.Context context;
- private static class MetricWs implements WebService {
@Override
- public void define(Context context) {
- NewController newController = context
- .createController("api/metric")
- .setDescription("Metrics")
- .setSince("3.2");
-
- // action with default values
- newController.createAction("show")
- .setSince("3.2")
- .setDescription("Show Description")
- .setResponseExample(getClass().getResource("web-services-ws-test.txt"))
- .setHandler((request, response) -> {
- });
-
- // action with a lot of overridden values
- NewAction create = newController.createAction("create")
- .setPost(true)
- .setDescription("Create metric")
- .setSince("4.1")
- .setDeprecatedSince("5.3")
- .setResponseExample(Resources.getResource(getClass(), "WebServicesWsTest/metrics_example.json"))
- .setChangelog(
- new Change("4.5", "Deprecate database ID in response"),
- new Change("6.0", "Remove database ID from response"),
- new Change("6.6", "Requires 'Administer System' permission instead of 'Administer Quality Profiles'"))
- .setHandler((request, response) -> {
- });
-
- create
- .createParam("severity")
- .setDescription("Severity")
- .setSince("4.4")
- .setDeprecatedSince("5.2")
- .setDeprecatedKey("old_severity", "4.6")
- .setRequired(false)
- .setPossibleValues("BLOCKER", "INFO")
- .setExampleValue("INFO")
- .setDefaultValue("BLOCKER");
- create.createParam("name");
- create.createParam("internal").setInternal(true);
-
- create
- .createParam("constrained_string_param")
- .setMaximumLength(64)
- .setMinimumLength(3);
+ public void setContext(WebService.Context context) {
+ this.context = context;
+ }
- create
- .createParam("constrained_numeric_param")
- .setMaximumValue(12);
+ @Override
+ public void define(WebService.NewController context) {
+ context.createAction("foo").setHandler(this);
+ }
- newController.createAction("internal_action")
- .setDescription("Internal Action Description")
- .setResponseExample(getClass().getResource("web-services-ws-test.txt"))
- .setSince("5.3")
- .setInternal(true)
- .setHandler((request, response) -> {
- });
+ @Override
+ public void handle(Request request, Response response) {
- newController.done();
}
}
}
+++ /dev/null
-{
- "languages": [
- {"key": "ac", "name": "ArnoldC"},
- {"key": "lol", "name": "LOLCODE"},
- {"key": "ook", "name": "Ook!"},
- {"key": "ws", "name": "Whitespace"}
- ]
-}
+++ /dev/null
-{
- "languages": [
- {"key": "ws", "name": "Whitespace"}
- ]
-}
+++ /dev/null
-{
- "languages": [
- {"key": "ac", "name": "ArnoldC"},
- {"key": "lol", "name": "LOLCODE"},
- {"key": "ook", "name": "Ook!"}
- ]
-}
+++ /dev/null
-{
- "languages": [
- {"key": "ac", "name": "ArnoldC"},
- {"key": "lol", "name": "LOLCODE"}
- ]
-}
--- /dev/null
+{
+ "languages": [
+ {"key": "ac", "name": "ArnoldC"},
+ {"key": "lol", "name": "LOLCODE"},
+ {"key": "ook", "name": "Ook!"},
+ {"key": "ws", "name": "Whitespace"}
+ ]
+}
--- /dev/null
+{
+ "languages": [
+ {"key": "ws", "name": "Whitespace"}
+ ]
+}
--- /dev/null
+{
+ "languages": [
+ {"key": "ac", "name": "ArnoldC"},
+ {"key": "lol", "name": "LOLCODE"},
+ {"key": "ook", "name": "Ook!"}
+ ]
+}
--- /dev/null
+{
+ "languages": [
+ {"key": "ac", "name": "ArnoldC"},
+ {"key": "lol", "name": "LOLCODE"}
+ ]
+}
--- /dev/null
+{
+ "webServices": [
+ {
+ "path": "api/metric",
+ "since": "3.2",
+ "description": "Metrics",
+ "actions": [
+ {
+ "key": "create",
+ "description": "Create metric",
+ "since": "4.1",
+ "internal": false,
+ "post": true,
+ "hasResponseExample": true,
+ "params": [
+ {
+ "key": "constrained_numeric_param",
+ "required": false,
+ "internal": false,
+ "maximumValue": 12
+ },
+ {
+ "key": "constrained_string_param",
+ "required": false,
+ "internal": false,
+ "maximumLength": 64,
+ "minimumLength": 3
+ },
+ {
+ "key": "name",
+ "required": false,
+ "internal": false
+ },
+ {
+ "key": "severity",
+ "description": "Severity",
+ "required": false,
+ "internal": false,
+ "defaultValue": "BLOCKER",
+ "exampleValue": "INFO",
+ "possibleValues": [
+ "BLOCKER",
+ "INFO"
+ ]
+ },
+ {
+ "key": "internal",
+ "required": false,
+ "internal": true
+ }
+ ]
+ },
+ {
+ "key": "internal_action",
+ "since": "5.3",
+ "internal": true,
+ "post": false,
+ "hasResponseExample": true
+ },
+ {
+ "key": "show",
+ "since": "3.2",
+ "internal": false,
+ "post": false,
+ "hasResponseExample": true
+ }
+ ]
+ },
+ {
+ "path": "api/webservices",
+ "description": "Get information on the web api supported on this instance.",
+ "since": "4.2",
+ "actions": [
+ {
+ "key": "list",
+ "since": "4.2",
+ "description": "List web services",
+ "internal": false,
+ "post": false,
+ "hasResponseExample": true,
+ "params": [
+ {
+ "key": "include_internals",
+ "description": "Include web services that are implemented for internal use only. Their forward-compatibility is not assured",
+ "required": false,
+ "internal": false,
+ "defaultValue": "false",
+ "possibleValues": [
+ "true",
+ "false",
+ "yes",
+ "no"
+ ]
+ }
+ ]
+ },
+ {
+ "key": "response_example",
+ "since": "4.4",
+ "description": "Display web service response example",
+ "internal": false,
+ "post": false,
+ "hasResponseExample": true,
+ "params": [
+ {
+ "key": "action",
+ "required": true,
+ "internal": false,
+ "description": "Action of the web service",
+ "exampleValue": "search"
+ },
+ {
+ "key": "controller",
+ "required": true,
+ "internal": false,
+ "description": "Controller of the web service",
+ "exampleValue": "api/issues"
+ }
+ ]
+ }
+ ]
+ }
+ ]
+}
--- /dev/null
+{"metrics":[]}
--- /dev/null
+{"format":"json","example":"{\"metrics\":[]}"}
+++ /dev/null
-{
- "webServices": [
- {
- "path": "api/metric",
- "since": "3.2",
- "description": "Metrics",
- "actions": [
- {
- "key": "create",
- "description": "Create metric",
- "since": "4.1",
- "internal": false,
- "post": true,
- "hasResponseExample": true,
- "params": [
- {
- "key": "constrained_numeric_param",
- "required": false,
- "internal": false,
- "maximumValue": 12
- },
- {
- "key": "constrained_string_param",
- "required": false,
- "internal": false,
- "maximumLength": 64,
- "minimumLength": 3
- },
- {
- "key": "name",
- "required": false,
- "internal": false
- },
- {
- "key": "severity",
- "description": "Severity",
- "required": false,
- "internal": false,
- "defaultValue": "BLOCKER",
- "exampleValue": "INFO",
- "possibleValues": [
- "BLOCKER",
- "INFO"
- ]
- },
- {
- "key": "internal",
- "required": false,
- "internal": true
- }
- ]
- },
- {
- "key": "internal_action",
- "since": "5.3",
- "internal": true,
- "post": false,
- "hasResponseExample": true
- },
- {
- "key": "show",
- "since": "3.2",
- "internal": false,
- "post": false,
- "hasResponseExample": true
- }
- ]
- },
- {
- "path": "api/webservices",
- "description": "Get information on the web api supported on this instance.",
- "since": "4.2",
- "actions": [
- {
- "key": "list",
- "since": "4.2",
- "description": "List web services",
- "internal": false,
- "post": false,
- "hasResponseExample": true,
- "params": [
- {
- "key": "include_internals",
- "description": "Include web services that are implemented for internal use only. Their forward-compatibility is not assured",
- "required": false,
- "internal": false,
- "defaultValue": "false",
- "possibleValues": [
- "true",
- "false",
- "yes",
- "no"
- ]
- }
- ]
- },
- {
- "key": "response_example",
- "since": "4.4",
- "description": "Display web service response example",
- "internal": false,
- "post": false,
- "hasResponseExample": true,
- "params": [
- {
- "key": "action",
- "required": true,
- "internal": false,
- "description": "Action of the web service",
- "exampleValue": "search"
- },
- {
- "key": "controller",
- "required": true,
- "internal": false,
- "description": "Controller of the web service",
- "exampleValue": "api/issues"
- }
- ]
- }
- ]
- }
- ]
-}
+++ /dev/null
-{"metrics":[]}
+++ /dev/null
-{"format":"json","example":"{\"metrics\":[]}"}
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.lang.reflect.Method;
+import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import javax.annotation.CheckForNull;
import org.sonar.test.JsonAssert;
+import static org.assertj.core.api.Assertions.assertThat;
+
public class TestResponse {
private final DumbResponse dumbResponse;
- TestResponse(DumbResponse dumbResponse) {
+ public TestResponse(DumbResponse dumbResponse) {
this.dumbResponse = dumbResponse;
}
}
JsonAssert.assertJson(getInput()).isSimilarTo(url);
}
+
+ public void assertNoContent() {
+ assertThat(getStatus()).isEqualTo(HttpURLConnection.HTTP_NO_CONTENT);
+ }
}
+++ /dev/null
-/*
- * SonarQube
- * Copyright (C) 2009-2019 SonarSource SA
- * mailto:info AT sonarsource DOT com
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 3 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-package org.sonar.server.ws;
-
-import com.google.common.collect.Maps;
-import java.io.ByteArrayOutputStream;
-import java.io.InputStream;
-import java.io.OutputStream;
-import java.io.OutputStreamWriter;
-import java.net.HttpURLConnection;
-import java.net.URL;
-import java.nio.charset.StandardCharsets;
-import java.util.Collection;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.stream.Collectors;
-import javax.annotation.CheckForNull;
-import javax.annotation.Nullable;
-import org.apache.commons.io.IOUtils;
-import org.sonar.api.server.ws.Response;
-import org.sonar.api.server.ws.WebService;
-import org.sonar.api.impl.ws.PartImpl;
-import org.sonar.api.impl.ws.ValidatingRequest;
-import org.sonar.api.utils.text.JsonWriter;
-import org.sonar.api.utils.text.XmlWriter;
-import org.sonar.server.ws.WsTester.TestResponse.TestStream;
-import org.sonar.test.JsonAssert;
-import org.sonarqube.ws.MediaTypes;
-
-import static java.util.Collections.emptyList;
-import static java.util.Collections.singletonList;
-import static java.util.Objects.requireNonNull;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.sonar.server.ws.RequestVerifier.verifyRequest;
-
-/**
- * @since 4.2
- * @deprecated use {@link WsActionTester} in preference to this class
- */
-@Deprecated
-public class WsTester {
-
- public static class TestRequest extends ValidatingRequest {
-
- private final String method;
- private String path;
- private String mediaType = MediaTypes.JSON;
-
- private Map<String, String> params = Maps.newHashMap();
- private Map<String, String> headers = Maps.newHashMap();
- private final Map<String, Part> parts = Maps.newHashMap();
-
- private TestRequest(String method) {
- this.method = method;
- }
-
- @Override
- public String method() {
- return method;
- }
-
- @Override
- public String getMediaType() {
- return mediaType;
- }
-
- public TestRequest setMediaType(String s) {
- this.mediaType = s;
- return this;
- }
-
- @Override
- public boolean hasParam(String key) {
- return params.keySet().contains(key);
- }
-
- @Override
- public Optional<String> header(String name) {
- return Optional.ofNullable(headers.get(name));
- }
-
- public TestRequest setHeader(String name, String value) {
- this.headers.put(requireNonNull(name), requireNonNull(value));
- return this;
- }
-
- @Override
- public String getPath() {
- return path;
- }
-
- public TestRequest setPath(String path) {
- this.path = path;
- return this;
- }
-
- public TestRequest setParams(Map<String, String> m) {
- this.params = m;
- return this;
- }
-
- public TestRequest setParam(String key, @Nullable String value) {
- if (value != null) {
- params.put(key, value);
- }
- return this;
- }
-
- @Override
- protected String readParam(String key) {
- return params.get(key);
- }
-
- @Override
- protected List<String> readMultiParam(String key) {
- String value = params.get(key);
- return value == null ? emptyList() : singletonList(value);
- }
-
- @Override
- public Map<String, String[]> getParams() {
- return params.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new String[] {e.getValue()}));
- }
-
- @Override
- protected InputStream readInputStreamParam(String key) {
- String param = readParam(key);
-
- return param == null ? null : IOUtils.toInputStream(param);
- }
-
- @Override
- protected Part readPart(String key) {
- return parts.get(key);
- }
-
- public TestRequest setPart(String key, InputStream input, String fileName) {
- parts.put(key, new PartImpl(input, fileName));
- return this;
- }
-
- public Result execute() throws Exception {
- TestResponse response = new TestResponse();
- verifyRequest(action(), this);
- action().handler().handle(this, response);
- return new Result(response);
- }
- }
-
- public static class TestResponse implements Response {
-
- private TestStream stream;
-
- private Map<String, String> headers = Maps.newHashMap();
-
- public class TestStream implements Response.Stream {
- private String mediaType;
- private int status;
-
- @CheckForNull
- public String mediaType() {
- return mediaType;
- }
-
- public int status() {
- return status;
- }
-
- @Override
- public Response.Stream setMediaType(String s) {
- this.mediaType = s;
- return this;
- }
-
- @Override
- public Response.Stream setStatus(int i) {
- this.status = i;
- return this;
- }
-
- @Override
- public OutputStream output() {
- return output;
- }
- }
-
- private final ByteArrayOutputStream output = new ByteArrayOutputStream();
-
- @Override
- public JsonWriter newJsonWriter() {
- return JsonWriter.of(new OutputStreamWriter(output, StandardCharsets.UTF_8));
- }
-
- @Override
- public XmlWriter newXmlWriter() {
- return XmlWriter.of(new OutputStreamWriter(output, StandardCharsets.UTF_8));
- }
-
- @Override
- public Stream stream() {
- if (stream == null) {
- stream = new TestStream();
- }
- return stream;
- }
-
- @Override
- public Response noContent() {
- stream().setStatus(HttpURLConnection.HTTP_NO_CONTENT);
- IOUtils.closeQuietly(output);
- return this;
- }
-
- public String outputAsString() {
- return new String(output.toByteArray(), StandardCharsets.UTF_8);
- }
-
- @Override
- public Response setHeader(String name, String value) {
- headers.put(name, value);
- return this;
- }
-
- @Override
- public Collection<String> getHeaderNames() {
- return headers.keySet();
- }
-
- @Override
- public String getHeader(String name) {
- return headers.get(name);
- }
- }
-
- public static class Result {
- private final TestResponse response;
-
- private Result(TestResponse response) {
- this.response = response;
- }
-
- public Result assertNoContent() {
- return assertStatus(HttpURLConnection.HTTP_NO_CONTENT);
- }
-
- public String outputAsString() {
- return new String(response.output.toByteArray(), StandardCharsets.UTF_8);
- }
-
- public byte[] output() {
- return response.output.toByteArray();
- }
-
- public Result assertJson(String expectedJson) {
- String json = outputAsString();
- JsonAssert.assertJson(json).isSimilarTo(expectedJson);
- return this;
- }
-
- /**
- * Compares JSON response with JSON file available in classpath. For example if class
- * is org.foo.BarTest and filename is index.json, then file must be located
- * at src/test/resources/org/foo/BarTest/index.json.
- *
- * @param clazz the test class
- * @param expectedJsonFilename name of the file containing the expected JSON
- */
- public Result assertJson(Class clazz, String expectedJsonFilename) {
- String path = clazz.getSimpleName() + "/" + expectedJsonFilename;
- URL url = clazz.getResource(path);
- if (url == null) {
- throw new IllegalStateException("Cannot find " + path);
- }
- String json = outputAsString();
- JsonAssert.assertJson(json).isSimilarTo(url);
- return this;
- }
-
- public Result assertNotModified() {
- return assertStatus(HttpURLConnection.HTTP_NOT_MODIFIED);
- }
-
- public Result assertStatus(int httpStatus) {
- assertThat(((TestStream) response.stream()).status()).isEqualTo(httpStatus);
- return this;
- }
-
- public Result assertHeader(String name, String value) {
- assertThat(response.getHeader(name)).isEqualTo(value);
- return this;
- }
- }
-
- private final WebService.Context context = new WebService.Context();
-
- public WsTester(WebService... webServices) {
- for (WebService webService : webServices) {
- webService.define(context);
- }
- }
-
- public WebService.Context context() {
- return context;
- }
-
- @CheckForNull
- public WebService.Controller controller(String key) {
- return context.controller(key);
- }
-
- @CheckForNull
- public WebService.Action action(String controllerKey, String actionKey) {
- WebService.Controller controller = context.controller(controllerKey);
- if (controller != null) {
- return controller.action(actionKey);
- }
- return null;
- }
-
- public TestRequest newGetRequest(String controllerKey, String actionKey) {
- return newRequest(controllerKey, actionKey, "GET");
- }
-
- public TestRequest newPostRequest(String controllerKey, String actionKey) {
- return newRequest(controllerKey, actionKey, "POST");
- }
-
- private TestRequest newRequest(String controllerKey, String actionKey, String method) {
- TestRequest request = new TestRequest(method);
- WebService.Controller controller = context.controller(controllerKey);
- if (controller == null) {
- throw new IllegalArgumentException(
- String.format("Controller '%s' is unknown, did you forget to call NewController.done()?", controllerKey));
- }
- WebService.Action action = controller.action(actionKey);
- if (action == null) {
- throw new IllegalArgumentException(
- String.format("Action '%s' not found on controller '%s'.", actionKey, controllerKey));
- }
- request.setAction(action);
- return request;
- }
-}
projects / sonarqube.git / commitdiff