fix Request.mandatoryParam not failing on blank parameter value

server/sonar-server/src/main/java/org/sonar/server/permission/ws/RequestValidator.java

 
 import static com.google.common.base.Strings.isNullOrEmpty;
 import static java.lang.String.format;
-import static org.apache.commons.lang.StringUtils.isBlank;
 import static org.sonar.server.ws.WsUtils.checkRequest;
 import static org.sonarqube.ws.client.permission.PermissionsWsParameters.PARAM_PERMISSION;
 import static org.sonarqube.ws.client.permission.PermissionsWsParameters.PARAM_PROJECT_KEY_PATTERN;
 
 public class RequestValidator {
   public static final String MSG_TEMPLATE_WITH_SAME_NAME = "A template with the name '%s' already exists (case insensitive).";
-  private static final String MSG_TEMPLATE_NAME_NOT_BLANK = "The template name must not be blank";
   private final PermissionService permissionService;
   private final String allProjectsPermissionsOnOneLine;
 
       format("It is not possible to add the '%s' permission to group 'Anyone'.", permission));
   }
 
-  public static void validateTemplateNameFormat(String name) {
-    checkRequest(!isBlank(name), MSG_TEMPLATE_NAME_NOT_BLANK);
-  }
-
   public static void validateQualifier(@Nullable String qualifier, ResourceTypes resourceTypes) {
     if (qualifier == null) {
       return;

server/sonar-server/src/main/java/org/sonar/server/permission/ws/template/CreateTemplateAction.java

   }
 
   private void validateTemplateNameForCreation(DbSession dbSession, OrganizationDto org, String name) {
-    RequestValidator.validateTemplateNameFormat(name);
-
     PermissionTemplateDto permissionTemplateWithSameName = dbClient.permissionTemplateDao()
       .selectByName(dbSession, org.getUuid(), name);
     checkRequest(permissionTemplateWithSameName == null, format(MSG_TEMPLATE_WITH_SAME_NAME, name));

server/sonar-server/src/main/java/org/sonar/server/permission/ws/template/UpdateTemplateAction.java

 import org.sonar.server.permission.ws.RequestValidator;
 import org.sonar.server.permission.ws.WsParameters;
 import org.sonar.server.user.UserSession;
+import org.sonar.server.ws.WsUtils;
 import org.sonarqube.ws.Permissions.PermissionTemplate;
 import org.sonarqube.ws.Permissions.UpdateTemplateWsResponse;
 
 import static com.google.common.base.MoreObjects.firstNonNull;
 import static java.lang.String.format;
 import static java.util.Objects.requireNonNull;
+import static org.apache.commons.lang.StringUtils.isBlank;
 import static org.sonar.server.permission.PermissionPrivilegeChecker.checkGlobalAdmin;
 import static org.sonar.server.permission.ws.RequestValidator.MSG_TEMPLATE_WITH_SAME_NAME;
 import static org.sonar.server.permission.ws.template.PermissionTemplateDtoToPermissionTemplateResponse.toPermissionTemplateResponse;
   }
 
   private void validateTemplateNameForUpdate(DbSession dbSession, String organizationUuid, String name, long id) {
-    RequestValidator.validateTemplateNameFormat(name);
+    WsUtils.checkRequest(!isBlank(name), "The template name must not be blank");
 
     PermissionTemplateDto permissionTemplateWithSameName = dbClient.permissionTemplateDao().selectByName(dbSession, organizationUuid, name);
     checkRequest(permissionTemplateWithSameName == null || permissionTemplateWithSameName.getId() == id,

server/sonar-server/src/main/java/org/sonar/server/projectanalysis/ws/CreateEventAction.java

 import static com.google.common.base.Preconditions.checkState;
 import static java.lang.String.format;
 import static java.util.Optional.ofNullable;
-import static org.apache.commons.lang.StringUtils.isNotBlank;
 import static org.sonar.db.event.EventValidator.MAX_NAME_LENGTH;
 import static org.sonar.server.projectanalysis.ws.EventCategory.OTHER;
 import static org.sonar.server.projectanalysis.ws.EventCategory.VERSION;
   }
 
   private EventDto toDbEvent(CreateEventRequest request, SnapshotDto analysis) {
-    checkArgument(isNotBlank(request.getName()), "A non empty name is required");
     return new EventDto()
       .setUuid(uuidFactory.create())
       .setAnalysisUuid(analysis.getUuid())

server/sonar-server/src/main/java/org/sonar/server/projectanalysis/ws/SetBaselineAction.java

 
 import static com.google.common.base.Preconditions.checkArgument;
 import static java.lang.String.format;
+import static org.apache.commons.lang.StringUtils.trimToNull;
 import static org.sonar.server.component.ComponentFinder.ParamNames.PROJECT_ID_AND_KEY;
 import static org.sonar.server.projectanalysis.ws.ProjectAnalysesWsParameters.PARAM_ANALYSIS;
 import static org.sonar.server.projectanalysis.ws.ProjectAnalysesWsParameters.PARAM_BRANCH;
   }
 
   private void doHandle(Request request) {
-    String projectKey = mandatoryNonEmptyParam(request, PARAM_PROJECT);
-    String branchKey = request.param(PARAM_BRANCH);
-    checkArgument(branchKey == null || !branchKey.isEmpty(), "The '%s' parameter must not be empty", PARAM_BRANCH);
-    String analysisUuid = mandatoryNonEmptyParam(request, PARAM_ANALYSIS);
+    String projectKey = request.mandatoryParam(PARAM_PROJECT);
+    String branchKey = trimToNull(request.param(PARAM_BRANCH));
+    String analysisUuid = request.mandatoryParam(PARAM_ANALYSIS);
 
     try (DbSession dbSession = dbClient.openSession(false)) {
       ComponentDto projectBranch = getProjectBranch(dbSession, projectKey, branchKey);
     }
   }
 
-  private static String mandatoryNonEmptyParam(Request request, String param) {
-    String value = request.mandatoryParam(param);
-    checkArgument(!value.isEmpty(), "The '%s' parameter must not be empty", param);
-    return value;
-  }
-
   private ComponentDto getProjectBranch(DbSession dbSession, String projectKey, @Nullable String branchKey) {
     if (branchKey == null) {
       return componentFinder.getByUuidOrKey(dbSession, null, projectKey, PROJECT_ID_AND_KEY);

server/sonar-server/src/main/java/org/sonar/server/qualitygate/ws/CopyAction.java

 import org.sonar.server.qualitygate.QualityGateUpdater;
 import org.sonar.server.user.UserSession;
 
-import static com.google.common.base.Preconditions.checkArgument;
 import static org.sonar.db.permission.OrganizationPermission.ADMINISTER_QUALITY_GATES;
 import static org.sonar.server.qualitygate.ws.QualityGatesWs.parseId;
 import static org.sonar.server.qualitygate.ws.QualityGatesWsParameters.PARAM_ID;
     Long id = parseId(request, PARAM_ID);
     String destinationName = request.mandatoryParam(PARAM_NAME);
 
-    checkArgument(!destinationName.isEmpty(), "The 'name' parameter is empty");
-
     try (DbSession dbSession = dbClient.openSession(false)) {
 
       OrganizationDto organization = wsSupport.getOrganization(dbSession, request);

server/sonar-server/src/main/java/org/sonar/server/qualitygate/ws/CreateAction.java

 import org.sonar.server.user.UserSession;
 import org.sonarqube.ws.Qualitygates.CreateResponse;
 
-import static com.google.common.base.Preconditions.checkArgument;
 import static org.sonar.server.qualitygate.ws.QualityGatesWsParameters.ACTION_CREATE;
 import static org.sonar.server.qualitygate.ws.QualityGatesWsParameters.PARAM_NAME;
 import static org.sonar.server.ws.WsUtils.writeProtobuf;
       userSession.checkPermission(OrganizationPermission.ADMINISTER_QUALITY_GATES, organizationDto.getUuid());
 
       String name = request.mandatoryParam(PARAM_NAME);
-      checkArgument(!name.isEmpty(), "The 'name' parameter is empty");
 
       QualityGateDto newQualityGate = qualityGateUpdater.create(dbSession, organizationDto, name);
       CreateResponse.Builder createResponse = CreateResponse.newBuilder()

server/sonar-server/src/main/java/org/sonar/server/qualitygate/ws/RenameAction.java

 import org.sonarqube.ws.Qualitygates.QualityGate;
 
 import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Strings.isNullOrEmpty;
 import static org.sonar.server.qualitygate.ws.CreateAction.NAME_MAXIMUM_LENGTH;
 import static org.sonar.server.qualitygate.ws.QualityGatesWsParameters.PARAM_ID;
 import static org.sonar.server.qualitygate.ws.QualityGatesWsParameters.PARAM_NAME;
-import static org.sonar.server.util.Validation.CANT_BE_EMPTY_MESSAGE;
 import static org.sonar.server.ws.WsUtils.writeProtobuf;
 
 public class RenameAction implements QualityGatesWsAction {
   private QualityGateDto rename(DbSession dbSession, OrganizationDto organization, long id, String name) {
     QGateWithOrgDto qualityGate = wsSupport.getByOrganizationAndId(dbSession, organization, id);
     wsSupport.checkCanEdit(qualityGate);
-    checkArgument(!isNullOrEmpty(name), CANT_BE_EMPTY_MESSAGE, "Name");
     checkNotAlreadyExists(dbSession, organization, qualityGate, name);
     qualityGate.setName(name);
     dbClient.qualityGateDao().update(qualityGate, dbSession);

server/sonar-server/src/main/java/org/sonar/server/qualityprofile/ws/RenameAction.java

  */
 package org.sonar.server.qualityprofile.ws;
 
-import org.apache.commons.lang.StringUtils;
 import org.sonar.api.server.ws.Request;
 import org.sonar.api.server.ws.Response;
 import org.sonar.api.server.ws.WebService;
   }
 
   private void doHandle(String newName, String profileKey) {
-    checkRequest(StringUtils.isNotBlank(newName), "Name must be set");
     checkRequest(newName.length() <= MAXIMUM_NAME_LENGTH, "Name is too long (>%d characters)", MAXIMUM_NAME_LENGTH);
     userSession.checkLoggedIn();
 

server/sonar-server/src/main/java/org/sonar/server/setting/ws/EncryptAction.java

     userSession.checkIsSystemAdministrator();
 
     String value = request.mandatoryParam(PARAM_VALUE);
-    checkRequest(!value.isEmpty(), "Parameter '%s' must not be empty", PARAM_VALUE);
 
     Encryption encryption = settings.getEncryption();
     checkRequest(encryption.hasSecretKey(), "No secret key available");

server/sonar-server/src/main/java/org/sonar/server/setting/ws/SetAction.java

 
 import static com.google.common.base.Preconditions.checkArgument;
 import static java.lang.String.format;
-import static org.apache.commons.lang.StringUtils.isNotEmpty;
 import static org.sonar.server.setting.ws.SettingsWsParameters.PARAM_BRANCH;
 import static org.sonar.server.setting.ws.SettingsWsParameters.PARAM_COMPONENT;
 import static org.sonar.server.setting.ws.SettingsWsParameters.PARAM_FIELD_VALUES;
       .setComponent(request.param(PARAM_COMPONENT))
       .setBranch(request.param(PARAM_BRANCH))
       .setPullRequest(request.param(PARAM_PULL_REQUEST));
-    checkArgument(isNotEmpty(set.getKey()), "Setting key is mandatory and must not be empty");
     checkArgument(set.getValues() != null, "Setting values must not be null");
     checkArgument(set.getFieldValues() != null, "Setting fields values must not be null");
     return set;

server/sonar-server/src/main/java/org/sonar/server/usertoken/ws/GenerateAction.java

 
   private UserTokens.GenerateWsResponse doHandle(Request request) {
     try (DbSession dbSession = dbClient.openSession(false)) {
-      String name = getName(request);
+      String name = request.mandatoryParam(PARAM_NAME).trim();
       UserDto user = userTokenSupport.getUser(dbSession, request);
       checkTokenDoesNotAlreadyExists(dbSession, user, name);
 
     checkRequest(userTokenDto == null, "A user token for login '%s' and name '%s' already exists", user.getLogin(), name);
   }
 
-  private static String getName(Request request) {
-    String name = request.mandatoryParam(PARAM_NAME).trim();
-    checkRequest(!name.isEmpty(), "The '%s' parameter must not be blank", PARAM_NAME);
-    return name;
-  }
-
   private UserTokenDto insertTokenInDb(DbSession dbSession, UserDto user, String name, String tokenHash) {
     UserTokenDto userTokenDto = new UserTokenDto()
       .setUserUuid(user.getUuid())

server/sonar-server/src/test/java/org/sonar/server/permission/ws/template/CreateTemplateActionTest.java

   }
 
   @Test
-  public void create_full_permission_template() throws Exception {
+  public void create_full_permission_template() {
     loginAsAdmin(db.getDefaultOrganization());
 
     TestResponse result = newRequest("Finance", "Permissions for financially related projects", ".*\\.finance\\..*");
   }
 
   @Test
-  public void create_minimalist_permission_template() throws Exception {
+  public void create_minimalist_permission_template() {
     loginAsAdmin(db.getDefaultOrganization());
 
     newRequest("Finance", null, null);
   }
 
   @Test
-  public void fail_if_name_not_provided() throws Exception {
+  public void fail_if_name_not_provided() {
     loginAsAdmin(db.getDefaultOrganization());
 
     expectedException.expect(IllegalArgumentException.class);
   }
 
   @Test
-  public void fail_if_name_empty() throws Exception {
+  public void fail_if_name_empty() {
     loginAsAdmin(db.getDefaultOrganization());
 
-    expectedException.expect(BadRequestException.class);
-    expectedException.expectMessage("The template name must not be blank");
+    expectedException.expect(IllegalArgumentException.class);
+    expectedException.expectMessage("The 'name' parameter is missing");
 
     newRequest("", null, null);
   }
 
   @Test
-  public void fail_if_regexp_if_not_valid() throws Exception {
+  public void fail_if_regexp_if_not_valid() {
     loginAsAdmin(db.getDefaultOrganization());
 
     expectedException.expect(BadRequestException.class);
   }
 
   @Test
-  public void fail_if_name_already_exists_in_database_case_insensitive() throws Exception {
+  public void fail_if_name_already_exists_in_database_case_insensitive() {
     loginAsAdmin(db.getDefaultOrganization());
     PermissionTemplateDto template = db.permissionTemplates().insertTemplate(db.getDefaultOrganization());
 
   }
 
   @Test
-  public void fail_if_not_admin() throws Exception {
+  public void fail_if_not_admin() {
     userSession.logIn().addPermission(ADMINISTER_QUALITY_PROFILES, db.getDefaultOrganization());
 
     expectedException.expect(ForbiddenException.class);

server/sonar-server/src/test/java/org/sonar/server/permission/ws/template/UpdateTemplateActionTest.java

   }
 
   @Test
-  public void update_all_permission_template_fields() throws Exception {
+  public void update_all_permission_template_fields() {
     loginAsAdmin(db.getDefaultOrganization());
 
     String result = call(template.getUuid(), "Finance", "Permissions for financially related projects", ".*\\.finance\\..*");
   }
 
   @Test
-  public void update_with_the_same_values() throws Exception {
+  public void update_with_the_same_values() {
     loginAsAdmin(db.getDefaultOrganization());
 
     call(template.getUuid(), template.getName(), template.getDescription(), template.getKeyPattern());
   }
 
   @Test
-  public void update_name_only() throws Exception {
+  public void update_name_only() {
     loginAsAdmin(db.getDefaultOrganization());
 
     call(template.getUuid(), "Finance", null, null);
   }
 
   @Test
-  public void fail_if_key_is_not_found() throws Exception {
+  public void fail_if_key_is_not_found() {
     loginAsAdmin(db.getDefaultOrganization());
 
     expectedException.expect(NotFoundException.class);
   }
 
   @Test
-  public void fail_if_name_already_exists_in_another_template() throws Exception {
+  public void fail_if_name_already_exists_in_another_template() {
     loginAsAdmin(db.getDefaultOrganization());
     PermissionTemplateDto anotherTemplate = addTemplateToDefaultOrganization();
 
   }
 
   @Test
-  public void fail_if_key_is_not_provided() throws Exception {
+  public void fail_if_key_is_not_provided() {
     loginAsAdmin(db.getDefaultOrganization());
 
     expectedException.expect(IllegalArgumentException.class);
   }
 
   @Test
-  public void fail_if_name_empty() throws Exception {
+  public void fail_if_name_empty() {
     loginAsAdmin(db.getDefaultOrganization());
 
     expectedException.expect(BadRequestException.class);
   }
 
   @Test
-  public void fail_if_name_has_just_whitespaces() throws Exception {
+  public void fail_if_name_has_just_whitespaces() {
     loginAsAdmin(db.getDefaultOrganization());
 
     expectedException.expect(BadRequestException.class);
   }
 
   @Test
-  public void fail_if_regexp_if_not_valid() throws Exception {
+  public void fail_if_regexp_if_not_valid() {
     loginAsAdmin(db.getDefaultOrganization());
 
     expectedException.expect(BadRequestException.class);
   }
 
   @Test
-  public void fail_if_name_already_exists_in_database_case_insensitive() throws Exception {
+  public void fail_if_name_already_exists_in_database_case_insensitive() {
     loginAsAdmin(db.getDefaultOrganization());
     PermissionTemplateDto anotherTemplate = addTemplateToDefaultOrganization();
 
   }
 
   @Test
-  public void fail_if_not_logged_in() throws Exception {
+  public void fail_if_not_logged_in() {
     expectedException.expect(UnauthorizedException.class);
     userSession.anonymous();
 
   }
 
   @Test
-  public void fail_if_not_admin() throws Exception {
+  public void fail_if_not_admin() {
     userSession.logIn().addPermission(SCAN, db.getDefaultOrganization());
 
     expectedException.expect(ForbiddenException.class);

server/sonar-server/src/test/java/org/sonar/server/projectanalysis/ws/CreateEventActionTest.java

     logInAsProjectAdministrator(project);
 
     expectedException.expect(IllegalArgumentException.class);
-    expectedException.expectMessage("A non empty name is required");
+    expectedException.expectMessage("The 'name' parameter is missing");
 
     call(OTHER.name(), "    ", analysis.getUuid());
   }

server/sonar-server/src/test/java/org/sonar/server/projectanalysis/ws/SetBaselineActionTest.java

   private WsActionTester ws = new WsActionTester(new SetBaselineAction(dbClient, userSession, TestComponentFinder.from(db)));
 
   @Test
-  public void set_baseline_on_main_branch() {
+  @UseDataProvider("nullOrEmpty")
+  public void set_baseline_on_main_branch(@Nullable String branchName) {
     ComponentDto project = ComponentTesting.newPrivateProjectDto(db.organizations().insert());
     BranchDto branch = new BranchDto()
       .setBranchType(BranchType.LONG)
     SnapshotDto analysis = db.components().insertSnapshot(project);
     logInAsProjectAdministrator(project);
 
-    call(ImmutableMap.of(PARAM_PROJECT, project.getKey(), PARAM_ANALYSIS, analysis.getUuid()));
+    call(project.getKey(), branchName, analysis.getUuid());
 
     BranchDto loaded = dbClient.branchDao().selectByUuid(dbSession, branch.getUuid()).get();
     assertThat(loaded.getManualBaseline()).isEqualTo(analysis.getUuid());
   }
 
+  @DataProvider
+  public static Object[][] nullOrEmpty() {
+    return new Object[][] {
+      {null},
+      {""},
+      {"     "},
+    };
+  }
+
   @Test
   public void set_baseline_on_long_living_branch() {
     ComponentDto project = ComponentTesting.newPrivateProjectDto(db.organizations().insert());
 
     return new Object[][] {
       {builder.put(PARAM_PROJECT, null).map, "The 'project' parameter is missing"},
-      {builder.put(PARAM_PROJECT, "").map, "The 'project' parameter must not be empty"},
-      {builder.put(PARAM_BRANCH, "").map, "The 'branch' parameter must not be empty"},
+      {builder.put(PARAM_PROJECT, "").map, "The 'project' parameter is missing"},
       {builder.put(PARAM_ANALYSIS, null).map, "The 'analysis' parameter is missing"},
-      {builder.put(PARAM_ANALYSIS, "").map, "The 'analysis' parameter must not be empty"},
+      {builder.put(PARAM_ANALYSIS, "").map, "The 'analysis' parameter is missing"},
     };
   }
 
     httpRequest.execute();
   }
 
-  private void call(String projectKey, String branchKey, String analysisUuid) {
-    call(ImmutableMap.of(
-      PARAM_PROJECT, projectKey,
-      PARAM_BRANCH, branchKey,
-      PARAM_ANALYSIS, analysisUuid));
+  private void call(String projectKey, @Nullable String branchKey, String analysisUuid) {
+    if (branchKey == null) {
+      call(ImmutableMap.of(
+        PARAM_PROJECT, projectKey,
+        PARAM_ANALYSIS, analysisUuid));
+    } else {
+      call(ImmutableMap.of(
+        PARAM_PROJECT, projectKey,
+        PARAM_BRANCH, branchKey,
+        PARAM_ANALYSIS, analysisUuid));
+    }
   }
 
   private static class MapBuilder {

server/sonar-server/src/test/java/org/sonar/server/qualitygate/ws/CopyActionTest.java

  */
 package org.sonar.server.qualitygate.ws;
 
+import com.tngtech.java.junit.dataprovider.DataProvider;
+import com.tngtech.java.junit.dataprovider.DataProviderRunner;
+import com.tngtech.java.junit.dataprovider.UseDataProvider;
+import javax.annotation.Nullable;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
+import org.junit.runner.RunWith;
 import org.sonar.api.server.ws.WebService;
 import org.sonar.api.utils.System2;
 import org.sonar.core.util.UuidFactoryFast;
 import org.sonar.server.organization.TestDefaultOrganizationProvider;
 import org.sonar.server.qualitygate.QualityGateUpdater;
 import org.sonar.server.tester.UserSessionRule;
+import org.sonar.server.ws.TestRequest;
 import org.sonar.server.ws.WsActionTester;
 import org.sonarqube.ws.Qualitygates.QualityGate;
 
 import static java.lang.String.format;
+import static java.util.Optional.ofNullable;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.AssertionsForClassTypes.tuple;
 import static org.sonar.db.permission.OrganizationPermission.ADMINISTER_QUALITY_GATES;
 import static org.sonar.server.qualitygate.ws.QualityGatesWsParameters.PARAM_NAME;
 import static org.sonar.server.qualitygate.ws.QualityGatesWsParameters.PARAM_ORGANIZATION;
 
+@RunWith(DataProviderRunner.class)
 public class CopyActionTest {
 
   @Rule
   }
 
   @Test
-  public void fail_when_name_parameter_is_missing() {
+  @UseDataProvider("nullOrEmpty")
+  public void fail_when_name_parameter_is_missing(@Nullable String nameParameter) {
     OrganizationDto organization = db.organizations().insert();
     userSession.addPermission(ADMINISTER_QUALITY_GATES, organization);
     QualityGateDto qualityGate = db.qualityGates().insertQualityGate(organization);
 
-    expectedException.expect(IllegalArgumentException.class);
-    expectedException.expectMessage("The 'name' parameter is missing");
 
-    ws.newRequest()
+    TestRequest request = ws.newRequest()
       .setParam(PARAM_ID, qualityGate.getId().toString())
-      .setParam(PARAM_ORGANIZATION, organization.getKey())
-      .execute();
-  }
-
-  @Test
-  public void fail_when_name_parameter_is_empty() {
-    OrganizationDto organization = db.organizations().insert();
-    userSession.addPermission(ADMINISTER_QUALITY_GATES, organization);
-    QualityGateDto qualityGate = db.qualityGates().insertQualityGate(organization);
+      .setParam(PARAM_ORGANIZATION, organization.getKey());
+    ofNullable(nameParameter).ifPresent(t -> request.setParam(PARAM_NAME, t));
 
     expectedException.expect(IllegalArgumentException.class);
-    expectedException.expectMessage("The 'name' parameter is empty");
+    expectedException.expectMessage("The 'name' parameter is missing");
 
-    ws.newRequest()
-      .setParam(PARAM_ID, qualityGate.getId().toString())
-      .setParam(PARAM_NAME, "")
-      .setParam(PARAM_ORGANIZATION, organization.getKey())
-      .execute();
+    request.execute();
+  }
+
+  @DataProvider
+  public static Object[][] nullOrEmpty() {
+    return new Object[][] {
+      {null},
+      {""},
+      {"  "}
+    };
   }
 
   @Test

server/sonar-server/src/test/java/org/sonar/server/qualitygate/ws/CreateActionTest.java

  */
 package org.sonar.server.qualitygate.ws;
 
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.sonar.db.permission.OrganizationPermission.ADMINISTER_QUALITY_GATES;
-import static org.sonar.server.qualitygate.ws.QualityGatesWsParameters.PARAM_NAME;
-import static org.sonar.server.qualitygate.ws.QualityGatesWsParameters.PARAM_ORGANIZATION;
-
+import com.tngtech.java.junit.dataprovider.DataProvider;
+import com.tngtech.java.junit.dataprovider.DataProviderRunner;
+import com.tngtech.java.junit.dataprovider.UseDataProvider;
 import java.util.Optional;
-
+import javax.annotation.Nullable;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
+import org.junit.runner.RunWith;
 import org.sonar.api.server.ws.WebService;
 import org.sonar.api.utils.System2;
 import org.sonar.core.util.UuidFactoryFast;
 import org.sonar.server.organization.TestDefaultOrganizationProvider;
 import org.sonar.server.qualitygate.QualityGateUpdater;
 import org.sonar.server.tester.UserSessionRule;
+import org.sonar.server.ws.TestRequest;
 import org.sonar.server.ws.WsActionTester;
 import org.sonarqube.ws.Qualitygates.CreateResponse;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.sonar.db.permission.OrganizationPermission.ADMINISTER_QUALITY_GATES;
+import static org.sonar.server.qualitygate.ws.QualityGatesWsParameters.PARAM_NAME;
+import static org.sonar.server.qualitygate.ws.QualityGatesWsParameters.PARAM_ORGANIZATION;
+
+@RunWith(DataProviderRunner.class)
 public class CreateActionTest {
 
   @Rule
   }
 
   @Test
-  public void fail_when_name_parameter_is_empty() {
+  @UseDataProvider("nullOrEmpty")
+  public void fail_when_name_parameter_is_empty(@Nullable String nameParameter) {
     OrganizationDto org = db.organizations().insert();
     userSession.addPermission(ADMINISTER_QUALITY_GATES, org);
 
-    expectedException.expect(IllegalArgumentException.class);
-    expectedException.expectMessage("The 'name' parameter is empty");
-
-    ws.newRequest()
-      .setParam(PARAM_NAME, "")
-      .setParam(PARAM_ORGANIZATION, org.getKey())
-      .execute();
-  }
-
-  @Test
-  public void fail_when_name_parameter_is_missing() {
-    OrganizationDto org = db.organizations().insert();
-    userSession.addPermission(ADMINISTER_QUALITY_GATES, org);
+    TestRequest request = ws.newRequest()
+      .setParam(PARAM_ORGANIZATION, org.getKey());
+    Optional.ofNullable(nameParameter).ifPresent(t -> request.setParam(PARAM_NAME, ""));
 
     expectedException.expect(IllegalArgumentException.class);
     expectedException.expectMessage("The 'name' parameter is missing");
 
-    ws.newRequest()
-      .setParam(PARAM_ORGANIZATION, org.getKey())
-      .execute();
+    request.execute();
+  }
+
+  @DataProvider
+  public static Object[][] nullOrEmpty() {
+    return new Object[][] {
+      {null},
+      {""},
+      {"  "}
+    };
   }
 
   private CreateResponse executeRequest(Optional<OrganizationDto> organization, String qualitGateName) {

server/sonar-server/src/test/java/org/sonar/server/qualitygate/ws/RenameActionTest.java

     QGateWithOrgDto qualityGate = db.qualityGates().insertQualityGate(organization);
 
     expectedException.expect(IllegalArgumentException.class);
-    expectedException.expectMessage("Name can't be empty");
+    expectedException.expectMessage("The 'name' parameter is missing");
 
     ws.newRequest()
       .setParam("id", qualityGate.getId().toString())

server/sonar-server/src/test/java/org/sonar/server/qualityprofile/ws/RenameActionTest.java

   public void fail_if_blank_renaming() {
     String qualityProfileKey = createNewValidQualityProfileKey();
 
-    expectedException.expect(BadRequestException.class);
-    expectedException.expectMessage("Name must be set");
+    expectedException.expect(IllegalArgumentException.class);
+    expectedException.expectMessage("The 'name' parameter is missing");
 
     call(qualityProfileKey, " ");
   }

server/sonar-server/src/test/java/org/sonar/server/setting/ws/EncryptActionTest.java

   public void fail_if_value_is_empty() {
     logInAsSystemAdministrator();
 
-    expectedException.expect(BadRequestException.class);
-    expectedException.expectMessage("Parameter 'value' must not be empty");
+    expectedException.expect(IllegalArgumentException.class);
+    expectedException.expectMessage("The 'value' parameter is missing");
 
     call("  ");
   }

server/sonar-server/src/test/java/org/sonar/server/setting/ws/SetActionTest.java

   @Test
   public void fail_when_empty_key_value() {
     expectedException.expect(IllegalArgumentException.class);
-    expectedException.expectMessage("Setting key is mandatory and must not be empty");
+    expectedException.expectMessage("The 'key' parameter is missing");
 
     callForGlobalSetting("  ", "my value");
   }

server/sonar-server/src/test/java/org/sonar/server/user/ws/DeactivateActionTest.java

 package org.sonar.server.user.ws;
 
 import java.util.Optional;
+import javax.annotation.Nullable;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
 import org.sonar.server.tester.UserSessionRule;
 import org.sonar.server.user.index.UserIndexDefinition;
 import org.sonar.server.user.index.UserIndexer;
+import org.sonar.server.ws.TestRequest;
 import org.sonar.server.ws.TestResponse;
 import org.sonar.server.ws.WsActionTester;
 
   public void fail_if_login_is_blank() {
     logInAsSystemAdministrator();
 
-    expectedException.expect(NotFoundException.class);
-    expectedException.expectMessage("User '' doesn't exist");
+    expectedException.expect(IllegalArgumentException.class);
+    expectedException.expectMessage("The 'login' parameter is missing");
 
     deactivate("");
   }
 
+  @Test
+  public void fail_if_login_is_missing() {
+    logInAsSystemAdministrator();
+
+    expectedException.expect(IllegalArgumentException.class);
+    expectedException.expectMessage("The 'login' parameter is missing");
+
+    deactivate(null);
+  }
+
   @Test
   public void fail_to_deactivate_last_administrator_of_default_organization() {
     UserDto admin = db.users().insertUser();
     userSession.logIn().setSystemAdministrator();
   }
 
-  private TestResponse deactivate(String login) {
-    return ws.newRequest()
-      .setMethod("POST")
-      .setParam("login", login)
-      .execute();
+  private TestResponse deactivate(@Nullable String login) {
+    TestRequest request = ws.newRequest()
+      .setMethod("POST");
+    Optional.ofNullable(login).ifPresent(t -> request.setParam("login", login));
+    return request.execute();
   }
 
   private void verifyThatUserExists(String login) {

server/sonar-server/src/test/java/org/sonar/server/usertoken/ws/GenerateActionTest.java

     UserDto user = db.users().insertUser();
     logInAsSystemAdministrator();
 
-    expectedException.expect(BadRequestException.class);
-    expectedException.expectMessage("The 'name' parameter must not be blank");
+    expectedException.expect(IllegalArgumentException.class);
+    expectedException.expectMessage("The 'name' parameter is missing");
 
     newRequest(user.getLogin(), "   ");
   }

sonar-plugin-api/src/main/java/org/sonar/api/server/ws/Request.java

    */
   public String mandatoryParam(String key) {
     String value = param(key);
-    checkArgument(value != null, format(MSG_PARAMETER_MISSING, key));
+    checkArgument(value != null && !value.isEmpty(), format(MSG_PARAMETER_MISSING, key));
     return value;
   }