org.springframework.validation.Errors.getFieldError()

@Test
public void saveOrder_shouldNotSaveOrderIfInvalidOrderGroupPatient() {
    executeDataSet(ORDER_SET);
    OrderGroup orderGroup = new OrderGroup();
    orderGroup.setEncounter(Context.getEncounterService().getEncounter(5));
    orderGroup.setPatient(Context.getPatientService().getPatient(2));
    Order order = new OrderBuilder().withAction(Order.Action.NEW).withPatient(7).withConcept(1000).withCareSetting(1).withOrderer(1).withEncounter(3).withDateActivated(new Date()).withOrderType(17).withUrgency(Order.Urgency.ON_SCHEDULED_DATE).withScheduledDate(new Date()).withOrderGroup(orderGroup).build();
    Errors errors = new BindException(order, "order");
    new OrderValidator().validate(order, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("patient"));
    replacedert.replacedertEquals("Order.error.orderPatientAndOrderGroupPatientMismatch", errors.getFieldError("patient").getCode());
}

/**
 * @see AllergyValidator#validate(Object, org.springframework.validation.Errors)
 */
@Test
public void validate_shouldFailIfPatientIsNull() {
    validator.validate(allergy, errors);
    replacedertTrue(errors.hasFieldErrors("patient"));
    replacedertThat(errors.getFieldError("patient").getCode(), is("allergyapi.patient.required"));
}

/**
 * @see AllergyValidator#validate(Object, org.springframework.validation.Errors)
 */
@Test
public void validate_shouldFailIfAllergenIsNull() {
    validator.validate(allergy, errors);
    replacedertTrue(errors.hasFieldErrors("allergen"));
    replacedertThat(errors.getFieldError("allergen").getCode(), is("allergyapi.allergen.required"));
}

@Test
public void test_addConceptType_uriExists() {
    Mockito.when(conceptTypeManager.getByUriAndOwner(conceptTypeForm.getUri(), user)).thenReturn(conceptType);
    conceptTypeValidator.validate(conceptTypeForm, errors);
    replacedertNotNull(errors.getFieldError(URI_STRING));
}

@Test
public void test_editConceptType_ownerOnly() {
    User user1 = new User();
    user1.setUsername("user1");
    conceptTypeForm.setConceptTypeId(CONCEPT_TYPE_ID);
    dbConceptType.setOwner(user1);
    Mockito.when(conceptTypeManager.get(CONCEPT_TYPE_ID)).thenReturn(dbConceptType);
    Mockito.when(conceptTypeManager.getByUriAndOwner(conceptTypeForm.getUri(), user)).thenReturn(conceptType);
    conceptTypeValidator.validate(conceptTypeForm, errors);
    replacedertNotNull(errors.getFieldError(URI_STRING));
}

@Test
public void test_editConceptType_uriExists() {
    conceptTypeForm.setConceptTypeId(CONCEPT_TYPE_ID);
    dbConceptType.setUri(URI_EXISTING);
    Mockito.when(conceptTypeManager.get(CONCEPT_TYPE_ID)).thenReturn(dbConceptType);
    Mockito.when(conceptTypeManager.getByUriAndOwner(conceptTypeForm.getUri(), user)).thenReturn(conceptType);
    conceptTypeValidator.validate(conceptTypeForm, errors);
    replacedertNotNull(errors.getFieldError(URI_STRING));
}

@Test
public void test_addConcept_uriExists() {
    Mockito.when(conceptManager.getByUriAndOwner(conceptForm.getUri(), user)).thenReturn(concept);
    citationConceptValidator.validate(conceptForm, errors);
    replacedertNotNull(errors.getFieldError(URI_STRING));
}

@Test
public void SiteOptionMapDtoValidationTests() {
    SiteOptionMapDTO siteOptionMapDTO = SiteOptionMapDTO.withGeneralSettings(null, siteOptions.getSiteDescription(), siteOptions.getAddGooglereplacedytics(), siteOptions.getGooglereplacedyticsTrackingId(), siteOptions.getUserRegistration()).build();
    Errors errors = new BeanPropertyBindingResult(siteOptionMapDTO, "siteOptionMapDTO");
    ValidationUtils.invokeValidator(new SiteOptionMapDtoValidator(), siteOptionMapDTO, errors);
    replacedertTrue(errors.hasFieldErrors("siteName"));
    replacedertEquals("EMPTY", errors.getFieldError("siteName").getCode());
}

@Test
public void ShouldHasUsernameValidationError() {
    MedicValidator medicValidator = new MedicValidator();
    Medic medic = new Medic();
    medic.setEmail("email");
    medic.setPreplacedword("preplacedword");
    Errors errors = new BeanPropertyBindingResult(medic, "medic");
    medicValidator.validate(medic, errors);
    replacedertThat(errors.hasErrors()).isTrue();
    replacedertThat(errors.getErrorCount()).isEqualTo(1);
    replacedertThat(errors.getFieldError("username")).isNotNull();
}

/**
 * @see RoleValidator#validate(Object,Errors)
 */
@Test
public void validate_shouldFailValidationIfRoleHasLeadingOrTrailingSpace() {
    Role role = new Role();
    role.setDescription("some text");
    role.setRole(" Bowling race car driver");
    Errors errors = new BindException(role, "type");
    new RoleValidator().validate(role, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("role"));
    replacedert.replacedertEquals("error.trailingSpaces", errors.getFieldError("role").getCode());
    role.setRole("Bowling race car driver ");
    errors = new BindException(role, "role");
    new RoleValidator().validate(role, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("role"));
    replacedert.replacedertEquals("error.trailingSpaces", errors.getFieldError("role").getCode());
}

/**
 * @see ProviderValidator#validate(Object, Errors)
 */
@Test
public void validate_shouldBeInvalidIfPersonIsNotSet() {
    // given
    provider.setIdentifier("id");
    provider.setPerson(null);
    // when
    providerValidator.validate(provider, errors);
    // then
    replacedert.replacedertTrue(errors.hasErrors());
    replacedert.replacedertTrue(errors.hasFieldErrors("name"));
    replacedert.replacedertTrue(errors.hasFieldErrors("person"));
    replacedert.replacedertEquals("Provider.error.personOrName.required", errors.getFieldError("name").getCode());
    replacedert.replacedertEquals("Provider.error.personOrName.required", errors.getFieldError("person").getCode());
}

/**
 * @see ImplementationIdValidator#validate(Object,Errors)
 */
@Test
public void validate_shouldFailIfGivenACaretInTheImplementationIdCode() {
    ImplementationId invalidId = new ImplementationId();
    invalidId.setImplementationId("caret^caret");
    invalidId.setName("an invalid impl id for a unit test");
    invalidId.setPreplacedphrase("some valid preplacedphrase");
    invalidId.setDescription("Some valid description");
    Errors errors = new BindException(invalidId, "implementationId");
    new ImplementationIdValidator().validate(invalidId, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("implementationId"));
    replacedert.replacedertEquals("ImplementationId.implementationId.invalidCharacter", errors.getFieldError("implementationId").getCode());
}

/**
 * @see ImplementationIdValidator#validate(Object,Errors)
 */
@Test
public void validate_shouldFailIfGivenAPipeInTheImplementationIdCode() {
    // save an impl id with an invalid hl7 code
    ImplementationId invalidId2 = new ImplementationId();
    invalidId2.setImplementationId("pipe|pipe");
    invalidId2.setName("an invalid impl id for a unit test");
    invalidId2.setPreplacedphrase("some valid preplacedphrase");
    invalidId2.setDescription("Some valid description");
    Errors errors = new BindException(invalidId2, "implementationId");
    new ImplementationIdValidator().validate(invalidId2, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("implementationId"));
    replacedert.replacedertEquals("ImplementationId.implementationId.invalidCharacter", errors.getFieldError("implementationId").getCode());
}

/**
 * @see CohortValidator#validate(Object, Errors)
 */
@Test
public void validate_shouldFailIfPatientIsVoided() {
    patient.setVoided(true);
    validator.validate(cohort, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("memberships"));
    String eMessage = "Patient " + patient.getPatientId() + " is voided, cannot add voided members to a cohort";
    replacedert.replacedertEquals(eMessage, errors.getFieldError("memberships").getDefaultMessage());
}

/**
 * @see AllergyValidator#validate(Object, org.springframework.validation.Errors)
 */
@Test
public void validate_shouldFailIdAllergenTypeIsNull() {
    allergy.setAllergen(new Allergen());
    validator.validate(allergy, errors);
    replacedertTrue(errors.hasFieldErrors("allergen"));
    replacedertThat(errors.getFieldError("allergen").getCode(), is("allergyapi.allergenType.required"));
}

@Test
public void validate_shouldFailValidationIfAutoExpireDateIsNotSetAndDurationUnitsIsNotMappedToSNOMEDCTDuration() {
    DrugOrder drugOrder = createValidDrugOrder();
    drugOrder.setDuration(30);
    Concept unMappedDurationUnits = new Concept();
    drugOrder.setDurationUnits(unMappedDurationUnits);
    drugOrder.setAutoExpireDate(null);
    Errors errors = new BindException(drugOrder, "drugOrder");
    new SimpleDosingInstructions().validate(drugOrder, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("durationUnits"));
    replacedert.replacedertEquals("DrugOrder.error.durationUnitsNotMappedToSnomedCtDurationCode", errors.getFieldError("durationUnits").getCode());
}

@Test
public void test_editConcept_uriExists() {
    conceptForm.setConceptId(CONCEPT_ID);
    dbConcept.setUri(URI_EXISTING);
    Mockito.when(conceptManager.get(CONCEPT_ID)).thenReturn(dbConcept);
    Mockito.when(conceptManager.getByUriAndOwner(conceptForm.getUri(), user)).thenReturn(concept);
    citationConceptValidator.validate(conceptForm, errors);
    replacedertNotNull(errors.getFieldError(URI_STRING));
}

// 不能以下划线开头
@Test
public void valid_login_name_should_not_starts_with_underline() {
    UserValidator validator = new UserValidator(null, null, false);
    NewUserParam param = new NewUserParam();
    param.setLoginName("_a");
    Map<String, String> map = new HashMap<String, String>();
    Errors errors = new MapBindingResult(map, NewUserParam.clreplaced.getName());
    validator.validate(param, errors);
    replacedertThat(errors.hasErrors()).isTrue();
    replacedertThat(errors.getFieldError("loginName").getCode()).isEqualTo("NotValid.startsWithLetterOrNumber");
}

// 用户第一次登录时，要校验用户名是否存在
@Test
public void valid_login_name_is_used_when_first_login() {
    UserService userService = mock(UserService.clreplaced);
    UserInfo user = new UserInfo();
    when(userService.findByLoginName(anyString())).thenReturn(Optional.of(user));
    UserValidator validator = new UserValidator(userService, null, true);
    NewUserParam param = new NewUserParam();
    param.setLoginName("a");
    Map<String, String> map = new HashMap<String, String>();
    Errors errors = new MapBindingResult(map, NewUserParam.clreplaced.getName());
    validator.validate(param, errors);
    replacedertThat(errors.hasErrors()).isTrue();
    replacedertThat(errors.getFieldError("loginName").getCode()).isEqualTo("NotValid.loginNameIsUsed");
}

// 不能以下划线结尾
@Test
public void valid_login_name_should_not_ends_with_underline() {
    UserValidator validator = new UserValidator(null, null, false);
    NewUserParam param = new NewUserParam();
    param.setLoginName("a_");
    Map<String, String> map = new HashMap<String, String>();
    Errors errors = new MapBindingResult(map, NewUserParam.clreplaced.getName());
    validator.validate(param, errors);
    replacedertThat(errors.hasErrors()).isTrue();
    replacedertThat(errors.getFieldError("loginName").getCode()).isEqualTo("NotValid.endsWithLetterOrNumber");
}

// 不能以中划线开头
@Test
public void valid_login_name_should_not_starts_with_line_through() {
    UserValidator validator = new UserValidator(null, null, false);
    NewUserParam param = new NewUserParam();
    param.setLoginName("-a");
    Map<String, String> map = new HashMap<String, String>();
    Errors errors = new MapBindingResult(map, NewUserParam.clreplaced.getName());
    validator.validate(param, errors);
    replacedertThat(errors.hasErrors()).isTrue();
    replacedertThat(errors.getFieldError("loginName").getCode()).isEqualTo("NotValid.startsWithLetterOrNumber");
}

// 不能以中划线结尾
@Test
public void valid_login_name_should_not_ends_with_line_through() {
    UserValidator validator = new UserValidator(null, null, false);
    NewUserParam param = new NewUserParam();
    param.setLoginName("a-");
    Map<String, String> map = new HashMap<String, String>();
    Errors errors = new MapBindingResult(map, NewUserParam.clreplaced.getName());
    validator.validate(param, errors);
    replacedertThat(errors.hasErrors()).isTrue();
    replacedertThat(errors.getFieldError("loginName").getCode()).isEqualTo("NotValid.endsWithLetterOrNumber");
}

@Test
public void valid_login_name_should_not_empty() {
    UserValidator validator = new UserValidator(null, null, false);
    NewUserParam param = new NewUserParam();
    Map<String, String> map = new HashMap<String, String>();
    Errors errors = new MapBindingResult(map, NewUserParam.clreplaced.getName());
    validator.validate(param, errors);
    replacedertThat(errors.hasErrors()).isTrue();
    replacedertThat(errors.getFieldError("loginName").getCode()).isEqualTo("NotBlank.loginName");
}

// 只能包含字母、数字、下划线(_)或中划线(-)
@Test
public void valid_login_name_should_not_contains_chinese() {
    UserValidator validator = new UserValidator(null, null, false);
    NewUserParam param = new NewUserParam();
    param.setLoginName("a中文b");
    Map<String, String> map = new HashMap<String, String>();
    Errors errors = new MapBindingResult(map, NewUserParam.clreplaced.getName());
    validator.validate(param, errors);
    replacedertThat(errors.hasErrors()).isTrue();
    replacedertThat(errors.getFieldError("loginName").getCode()).isEqualTo("NotValid.onlyContainsLetterOrNumberOrUnderlineOrLineThrough");
}

@Test
public void testEscapedErrors() {
    TestBean tb = new TestBean();
    tb.setName("empty &");
    Errors errors = new EscapedErrors(new BindException(tb, "tb"));
    errors.rejectValue("name", "NAME_EMPTY &", null, "message: &");
    errors.rejectValue("age", "AGE_NOT_SET <tag>", null, "message: <tag>");
    errors.rejectValue("age", "AGE_NOT_32 <tag>", null, "message: <tag>");
    errors.reject("GENERAL_ERROR \" '", null, "message: \" '");
    replacedertTrue("Correct errors flag", errors.hasErrors());
    replacedertTrue("Correct number of errors", errors.getErrorCount() == 4);
    replacedertTrue("Correct object name", "tb".equals(errors.getObjectName()));
    replacedertTrue("Correct global errors flag", errors.hasGlobalErrors());
    replacedertTrue("Correct number of global errors", errors.getGlobalErrorCount() == 1);
    ObjectError globalError = errors.getGlobalError();
    String defaultMessage = globalError.getDefaultMessage();
    replacedertTrue("Global error message escaped", "message: " '".equals(defaultMessage));
    replacedertTrue("Global error code not escaped", "GENERAL_ERROR \" '".equals(globalError.getCode()));
    ObjectError globalErrorInList = errors.getGlobalErrors().get(0);
    replacedertTrue("Same global error in list", defaultMessage.equals(globalErrorInList.getDefaultMessage()));
    ObjectError globalErrorInAllList = errors.getAllErrors().get(3);
    replacedertTrue("Same global error in list", defaultMessage.equals(globalErrorInAllList.getDefaultMessage()));
    replacedertTrue("Correct field errors flag", errors.hasFieldErrors());
    replacedertTrue("Correct number of field errors", errors.getFieldErrorCount() == 3);
    replacedertTrue("Correct number of field errors in list", errors.getFieldErrors().size() == 3);
    FieldError fieldError = errors.getFieldError();
    replacedertTrue("Field error code not escaped", "NAME_EMPTY &".equals(fieldError.getCode()));
    replacedertTrue("Field value escaped", "empty &".equals(errors.getFieldValue("name")));
    FieldError fieldErrorInList = errors.getFieldErrors().get(0);
    replacedertTrue("Same field error in list", fieldError.getDefaultMessage().equals(fieldErrorInList.getDefaultMessage()));
    replacedertTrue("Correct name errors flag", errors.hasFieldErrors("name"));
    replacedertTrue("Correct number of name errors", errors.getFieldErrorCount("name") == 1);
    replacedertTrue("Correct number of name errors in list", errors.getFieldErrors("name").size() == 1);
    FieldError nameError = errors.getFieldError("name");
    replacedertTrue("Name error message escaped", "message: &".equals(nameError.getDefaultMessage()));
    replacedertTrue("Name error code not escaped", "NAME_EMPTY &".equals(nameError.getCode()));
    replacedertTrue("Name value escaped", "empty &".equals(errors.getFieldValue("name")));
    FieldError nameErrorInList = errors.getFieldErrors("name").get(0);
    replacedertTrue("Same name error in list", nameError.getDefaultMessage().equals(nameErrorInList.getDefaultMessage()));
    replacedertTrue("Correct age errors flag", errors.hasFieldErrors("age"));
    replacedertTrue("Correct number of age errors", errors.getFieldErrorCount("age") == 2);
    replacedertTrue("Correct number of age errors in list", errors.getFieldErrors("age").size() == 2);
    FieldError ageError = errors.getFieldError("age");
    replacedertTrue("Age error message escaped", "message: <tag>".equals(ageError.getDefaultMessage()));
    replacedertTrue("Age error code not escaped", "AGE_NOT_SET <tag>".equals(ageError.getCode()));
    replacedertTrue("Age value not escaped", (new Integer(0)).equals(errors.getFieldValue("age")));
    FieldError ageErrorInList = errors.getFieldErrors("age").get(0);
    replacedertTrue("Same name error in list", ageError.getDefaultMessage().equals(ageErrorInList.getDefaultMessage()));
    FieldError ageError2 = errors.getFieldErrors("age").get(1);
    replacedertTrue("Age error 2 message escaped", "message: <tag>".equals(ageError2.getDefaultMessage()));
    replacedertTrue("Age error 2 code not escaped", "AGE_NOT_32 <tag>".equals(ageError2.getCode()));
}

@Test
public void testEscapedErrors() {
    TestBean tb = new TestBean();
    tb.setName("empty &");
    Errors errors = new EscapedErrors(new BindException(tb, "tb"));
    errors.rejectValue("name", "NAME_EMPTY &", null, "message: &");
    errors.rejectValue("age", "AGE_NOT_SET <tag>", null, "message: <tag>");
    errors.rejectValue("age", "AGE_NOT_32 <tag>", null, "message: <tag>");
    errors.reject("GENERAL_ERROR \" '", null, "message: \" '");
    replacedertThat(errors.hasErrors()).as("Correct errors flag").isTrue();
    replacedertThat(errors.getErrorCount() == 4).as("Correct number of errors").isTrue();
    replacedertThat("tb".equals(errors.getObjectName())).as("Correct object name").isTrue();
    replacedertThat(errors.hasGlobalErrors()).as("Correct global errors flag").isTrue();
    replacedertThat(errors.getGlobalErrorCount() == 1).as("Correct number of global errors").isTrue();
    ObjectError globalError = errors.getGlobalError();
    String defaultMessage = globalError.getDefaultMessage();
    replacedertThat("message: " '".equals(defaultMessage)).as("Global error message escaped").isTrue();
    replacedertThat("GENERAL_ERROR \" '".equals(globalError.getCode())).as("Global error code not escaped").isTrue();
    ObjectError globalErrorInList = errors.getGlobalErrors().get(0);
    replacedertThat(defaultMessage.equals(globalErrorInList.getDefaultMessage())).as("Same global error in list").isTrue();
    ObjectError globalErrorInAllList = errors.getAllErrors().get(3);
    replacedertThat(defaultMessage.equals(globalErrorInAllList.getDefaultMessage())).as("Same global error in list").isTrue();
    replacedertThat(errors.hasFieldErrors()).as("Correct field errors flag").isTrue();
    replacedertThat(errors.getFieldErrorCount() == 3).as("Correct number of field errors").isTrue();
    replacedertThat(errors.getFieldErrors().size() == 3).as("Correct number of field errors in list").isTrue();
    FieldError fieldError = errors.getFieldError();
    replacedertThat("NAME_EMPTY &".equals(fieldError.getCode())).as("Field error code not escaped").isTrue();
    replacedertThat("empty &".equals(errors.getFieldValue("name"))).as("Field value escaped").isTrue();
    FieldError fieldErrorInList = errors.getFieldErrors().get(0);
    replacedertThat(fieldError.getDefaultMessage().equals(fieldErrorInList.getDefaultMessage())).as("Same field error in list").isTrue();
    replacedertThat(errors.hasFieldErrors("name")).as("Correct name errors flag").isTrue();
    replacedertThat(errors.getFieldErrorCount("name") == 1).as("Correct number of name errors").isTrue();
    replacedertThat(errors.getFieldErrors("name").size() == 1).as("Correct number of name errors in list").isTrue();
    FieldError nameError = errors.getFieldError("name");
    replacedertThat("message: &".equals(nameError.getDefaultMessage())).as("Name error message escaped").isTrue();
    replacedertThat("NAME_EMPTY &".equals(nameError.getCode())).as("Name error code not escaped").isTrue();
    replacedertThat("empty &".equals(errors.getFieldValue("name"))).as("Name value escaped").isTrue();
    FieldError nameErrorInList = errors.getFieldErrors("name").get(0);
    replacedertThat(nameError.getDefaultMessage().equals(nameErrorInList.getDefaultMessage())).as("Same name error in list").isTrue();
    replacedertThat(errors.hasFieldErrors("age")).as("Correct age errors flag").isTrue();
    replacedertThat(errors.getFieldErrorCount("age") == 2).as("Correct number of age errors").isTrue();
    replacedertThat(errors.getFieldErrors("age").size() == 2).as("Correct number of age errors in list").isTrue();
    FieldError ageError = errors.getFieldError("age");
    replacedertThat("message: <tag>".equals(ageError.getDefaultMessage())).as("Age error message escaped").isTrue();
    replacedertThat("AGE_NOT_SET <tag>".equals(ageError.getCode())).as("Age error code not escaped").isTrue();
    replacedertThat((new Integer(0)).equals(errors.getFieldValue("age"))).as("Age value not escaped").isTrue();
    FieldError ageErrorInList = errors.getFieldErrors("age").get(0);
    replacedertThat(ageError.getDefaultMessage().equals(ageErrorInList.getDefaultMessage())).as("Same name error in list").isTrue();
    FieldError ageError2 = errors.getFieldErrors("age").get(1);
    replacedertThat("message: <tag>".equals(ageError2.getDefaultMessage())).as("Age error 2 message escaped").isTrue();
    replacedertThat("AGE_NOT_32 <tag>".equals(ageError2.getCode())).as("Age error 2 code not escaped").isTrue();
}

@Test
public void testInnerRequiredFields() {
    IssueDefinition issueRQ = new IssueDefinition();
    JaskonRequiredPropertiesValidator validator = new JaskonRequiredPropertiesValidator();
    Errors errors = new BeanPropertyBindingResult(issueRQ, "issueRQ");
    validator.validate(issueRQ, errors);
    replacedertThat(errors.getAllErrors(), not(empty()));
    replacedertThat(errors.getFieldError("issue"), not(nullValue()));
}

@Override
public HttpResponse<?> handle(HttpRequest request, ValidationException exception) {
    Errors errors = exception.getErrors();
    FieldError fieldError = errors.getFieldError();
    MutableHttpResponse<?> response = HttpResponse.badRequest();
    if (responseProcessor != null) {
        return responseProcessor.processResponse(ErrorContext.builder(request).cause(exception).error(new Error() {

            @Override
            public String getMessage() {
                return exception.getMessage();
            }

            @Override
            public Optional<String> getPath() {
                return Optional.ofNullable(fieldError).map(FieldError::getField);
            }
        }).build(), response);
    } else {
        return response.body(new JsonError(exception.getMessage()).path(fieldError != null ? fieldError.getField() : null).link(Link.SELF, Link.of(request.getUri())));
    }
}

@Test
public void testEscapedErrors() {
    TestBean tb = new TestBean();
    tb.setName("empty &");
    Errors errors = new EscapedErrors(new BindException(tb, "tb"));
    errors.rejectValue("name", "NAME_EMPTY &", null, "message: &");
    errors.rejectValue("age", "AGE_NOT_SET <tag>", null, "message: <tag>");
    errors.rejectValue("age", "AGE_NOT_32 <tag>", null, "message: <tag>");
    errors.reject("GENERAL_ERROR \" '", null, "message: \" '");
    replacedertTrue("Correct errors flag", errors.hasErrors());
    replacedertTrue("Correct number of errors", errors.getErrorCount() == 4);
    replacedertTrue("Correct object name", "tb".equals(errors.getObjectName()));
    replacedertTrue("Correct global errors flag", errors.hasGlobalErrors());
    replacedertTrue("Correct number of global errors", errors.getGlobalErrorCount() == 1);
    ObjectError globalError = errors.getGlobalError();
    replacedertTrue("Global error message escaped", "message: " '".equals(globalError.getDefaultMessage()));
    replacedertTrue("Global error code not escaped", "GENERAL_ERROR \" '".equals(globalError.getCode()));
    ObjectError globalErrorInList = errors.getGlobalErrors().get(0);
    replacedertTrue("Same global error in list", globalError.getDefaultMessage().equals(globalErrorInList.getDefaultMessage()));
    ObjectError globalErrorInAllList = errors.getAllErrors().get(3);
    replacedertTrue("Same global error in list", globalError.getDefaultMessage().equals(globalErrorInAllList.getDefaultMessage()));
    replacedertTrue("Correct field errors flag", errors.hasFieldErrors());
    replacedertTrue("Correct number of field errors", errors.getFieldErrorCount() == 3);
    replacedertTrue("Correct number of field errors in list", errors.getFieldErrors().size() == 3);
    FieldError fieldError = errors.getFieldError();
    replacedertTrue("Field error code not escaped", "NAME_EMPTY &".equals(fieldError.getCode()));
    replacedertTrue("Field value escaped", "empty &".equals(errors.getFieldValue("name")));
    FieldError fieldErrorInList = errors.getFieldErrors().get(0);
    replacedertTrue("Same field error in list", fieldError.getDefaultMessage().equals(fieldErrorInList.getDefaultMessage()));
    replacedertTrue("Correct name errors flag", errors.hasFieldErrors("name"));
    replacedertTrue("Correct number of name errors", errors.getFieldErrorCount("name") == 1);
    replacedertTrue("Correct number of name errors in list", errors.getFieldErrors("name").size() == 1);
    FieldError nameError = errors.getFieldError("name");
    replacedertTrue("Name error message escaped", "message: &".equals(nameError.getDefaultMessage()));
    replacedertTrue("Name error code not escaped", "NAME_EMPTY &".equals(nameError.getCode()));
    replacedertTrue("Name value escaped", "empty &".equals(errors.getFieldValue("name")));
    FieldError nameErrorInList = errors.getFieldErrors("name").get(0);
    replacedertTrue("Same name error in list", nameError.getDefaultMessage().equals(nameErrorInList.getDefaultMessage()));
    replacedertTrue("Correct age errors flag", errors.hasFieldErrors("age"));
    replacedertTrue("Correct number of age errors", errors.getFieldErrorCount("age") == 2);
    replacedertTrue("Correct number of age errors in list", errors.getFieldErrors("age").size() == 2);
    FieldError ageError = errors.getFieldError("age");
    replacedertTrue("Age error message escaped", "message: <tag>".equals(ageError.getDefaultMessage()));
    replacedertTrue("Age error code not escaped", "AGE_NOT_SET <tag>".equals(ageError.getCode()));
    replacedertTrue("Age value not escaped", (new Integer(0)).equals(errors.getFieldValue("age")));
    FieldError ageErrorInList = errors.getFieldErrors("age").get(0);
    replacedertTrue("Same name error in list", ageError.getDefaultMessage().equals(ageErrorInList.getDefaultMessage()));
    FieldError ageError2 = errors.getFieldErrors("age").get(1);
    replacedertTrue("Age error 2 message escaped", "message: <tag>".equals(ageError2.getDefaultMessage()));
    replacedertTrue("Age error 2 code not escaped", "AGE_NOT_32 <tag>".equals(ageError2.getCode()));
}

/**
 * Process the given JSR-303 ConstraintViolations, adding corresponding errors to
 * the provided Spring {@link Errors} object.
 * @param violations the JSR-303 ConstraintViolation results
 * @param errors the Spring errors object to register to
 */
protected void processConstraintViolations(Set<ConstraintViolation<Object>> violations, Errors errors) {
    for (ConstraintViolation<Object> violation : violations) {
        String field = determineField(violation);
        FieldError fieldError = errors.getFieldError(field);
        if (fieldError == null || !fieldError.isBindingFailure()) {
            try {
                ConstraintDescriptor<?> cd = violation.getConstraintDescriptor();
                String errorCode = determineErrorCode(cd);
                Object[] errorArgs = getArgumentsForConstraint(errors.getObjectName(), field, cd);
                if (errors instanceof BindingResult) {
                    // Can do custom FieldError registration with invalid value from ConstraintViolation,
                    // as necessary for Hibernate Validator compatibility (non-indexed set path in field)
                    BindingResult bindingResult = (BindingResult) errors;
                    String nestedField = bindingResult.getNestedPath() + field;
                    if ("".equals(nestedField)) {
                        String[] errorCodes = bindingResult.resolveMessageCodes(errorCode);
                        bindingResult.addError(new ObjectError(errors.getObjectName(), errorCodes, errorArgs, violation.getMessage()));
                    } else {
                        Object rejectedValue = getRejectedValue(field, violation, bindingResult);
                        String[] errorCodes = bindingResult.resolveMessageCodes(errorCode, field);
                        bindingResult.addError(new FieldError(errors.getObjectName(), nestedField, rejectedValue, false, errorCodes, errorArgs, violation.getMessage()));
                    }
                } else {
                    // got no BindingResult - can only do standard rejectValue call
                    // with automatic extraction of the current field value
                    errors.rejectValue(field, errorCode, errorArgs, violation.getMessage());
                }
            } catch (NotReadablePropertyException ex) {
                throw new IllegalStateException("JSR-303 validated property '" + field + "' does not have a corresponding accessor for Spring data binding - " + "check your DataBinder's configuration (bean property versus direct field access)", ex);
            }
        }
    }
}

@Test
public void ShouldHasPreplacedwordValidationError() {
    MedicValidator medicValidator = new MedicValidator();
    Medic medic = new Medic();
    medic.setUsername("username");
    medic.setEmail("email");
    Errors errors = new BeanPropertyBindingResult(medic, "medic");
    medicValidator.validate(medic, errors);
    replacedertThat(errors.hasErrors()).isTrue();
    replacedertThat(errors.getErrorCount()).isEqualTo(1);
    replacedertThat(errors.getFieldError("preplacedword")).isNotNull();
}

@Test
public void ShouldHasEmailValidationError() {
    MedicValidator medicValidator = new MedicValidator();
    Medic medic = new Medic();
    medic.setUsername("username");
    medic.setPreplacedword("preplacedword");
    Errors errors = new BeanPropertyBindingResult(medic, "medic");
    medicValidator.validate(medic, errors);
    replacedertThat(errors.hasErrors()).isTrue();
    replacedertThat(errors.getErrorCount()).isEqualTo(1);
    replacedertThat(errors.getFieldError("email")).isNotNull();
}

/**
 * @see SchedulerFormValidator#validate(Object,Errors)
 */
@Test
public void validate_shouldFailValidationIfClreplacedCannotBeInstantiated() {
    TaskDefinition def = new TaskDefinition();
    def.setName("Creplaceds");
    def.setRepeatInterval(3600000L);
    def.setTaskClreplaced("org.openmrs.BaseOpenmrsData");
    Errors errors = new BindException(def, "def");
    new SchedulerFormValidator().validate(def, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("taskClreplaced"));
    replacedert.replacedertEquals("Scheduler.taskForm.instantiationException", errors.getFieldError("taskClreplaced").getCode());
}

/**
 * @see SchedulerFormValidator#validate(Object,Errors)
 */
@Test
public void validate_shouldFailValidationIfClreplacedIsNotAccessible() {
    TaskDefinition def = new TaskDefinition();
    def.setName("Creplaceds");
    def.setRepeatInterval(3600000L);
    // TODO: Find a way to trigger an IllegalAccessException
    def.setTaskClreplaced("???");
    Errors errors = new BindException(def, "def");
    new SchedulerFormValidator().validate(def, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("taskClreplaced"));
    replacedert.replacedertEquals("Scheduler.taskForm.clreplacedNotFoundException", errors.getFieldError("taskClreplaced").getCode());
}

/**
 * @see SchedulerFormValidator#validate(Object,Errors)
 */
@Test
public void validate_shouldFailValidationIfClreplacedIsNotInstanceOfTask() {
    TaskDefinition def = new TaskDefinition();
    def.setName("Creplaceds");
    def.setRepeatInterval(3600000L);
    def.setTaskClreplaced("org.openmrs.Obs");
    Errors errors = new BindException(def, "def");
    new SchedulerFormValidator().validate(def, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("taskClreplaced"));
    replacedert.replacedertEquals("Scheduler.taskForm.clreplacedDoesNotImplementTask", errors.getFieldError("taskClreplaced").getCode());
}

/**
 * @see SchedulerFormValidator#validate(Object,Errors)
 */
@Test
public void validate_shouldFailValidationIfClreplacedNotFound() {
    TaskDefinition def = new TaskDefinition();
    def.setName("Creplaceds");
    def.setRepeatInterval(3600000L);
    def.setTaskClreplaced("org.openmrs.ScaryRobot");
    Errors errors = new BindException(def, "def");
    new SchedulerFormValidator().validate(def, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("taskClreplaced"));
    replacedert.replacedertEquals("Scheduler.taskForm.clreplacedNotFoundException", errors.getFieldError("taskClreplaced").getCode());
}

/**
 * @see AllergyValidator#validate(Object, org.springframework.validation.Errors)
 */
@Test
public void validate_shouldFailIfCodedAndNonCodedAllergenAreNull() {
    Allergen allergen = new Allergen(AllergenType.DRUG, null, null);
    allergy.setAllergen(allergen);
    validator.validate(allergy, errors);
    replacedertTrue(errors.hasFieldErrors("allergen"));
    replacedertThat(errors.getFieldError("allergen").getCode(), is("allergyapi.allergen.codedOrNonCodedAllergen.required"));
}

/**
 * @see HibernateAdministrationDAO#validate(Object,Errors)
 */
@Test
public void validate_shouldFailValidationIfFieldLengthsAreNotCorrect() {
    String errorCode = "error.exceededMaxLengthOfField";
    String[] RoleFeilds = new String[] { "role", "description" };
    Role role = new Role();
    role.setRole("too long text too long text too long text too long text too long text too long text too long text too long text too long text too long text too long text too long text too long text too long text too long text too long text too long text too long text too long text too long text");
    role.setDescription("too long text too long text too long text too long text too long text too long text too long text too long text too long text too long text too long text too long text too long text too long text too long text too long text too long text too long text too long text too long text");
    Errors errors = new BindException(role, "type");
    dao.validate(role, errors);
    for (String feilds : RoleFeilds) {
        FieldError fielderror = errors.getFieldError(feilds);
        replacedert.replacedertTrue(errorCode.equals(fielderror.getCode()));
    }
}

@Test
public void test_editConcept_ownerOnly() {
    User user1 = new User();
    user1.setUsername("user1");
    conceptForm.setConceptId(CONCEPT_ID);
    dbConcept.setOwner(user1);
    Mockito.when(conceptManager.get(CONCEPT_ID)).thenReturn(dbConcept);
    Mockito.when(conceptManager.getByUriAndOwner(conceptForm.getUri(), user)).thenReturn(concept);
    citationConceptValidator.validate(conceptForm, errors);
    replacedertNotNull(errors.getFieldError(URI_STRING));
}

@Test
public void valid_login_name_should_not_be_keywords() {
    PropertyService propertyService = mock(PropertyService.clreplaced);
    List<CmProperty> keywords = new ArrayList<CmProperty>();
    CmProperty keyword1 = new CmProperty();
    keyword1.setValue("keyword_1");
    keywords.add(keyword1);
    when(propertyService.findAllByParentKey(anyString())).thenReturn(keywords);
    UserValidator validator = new UserValidator(null, propertyService, false);
    NewUserParam param = new NewUserParam();
    param.setLoginName("keyword_1");
    Map<String, String> map = new HashMap<String, String>();
    Errors errors = new MapBindingResult(map, NewUserParam.clreplaced.getName());
    validator.validate(param, errors);
    replacedertThat(errors.hasErrors()).isTrue();
    replacedertThat(errors.getFieldError("loginName").getCode()).isEqualTo("NotValid.loginNameIsUsed");
}

@ParameterizedTest
@MethodSource("invalidProperties")
public void validationFails(AwsSecretsManagerProperties properties, String field, String errorCode) {
    Errors errors = new BeanPropertyBindingResult(properties, "properties");
    properties.validate(properties, errors);
    replacedertThat(errors.getFieldError(field)).isNotNull();
    replacedertThat(errors.getFieldError(field).getCode()).isEqualTo(errorCode);
}

@Test
void acceptsForwardSlashAsProfileSeparator() {
    AwsParamStoreProperties properties = new AwsParamStoreProperties();
    properties.setProfileSeparator("/");
    Errors errors = new BeanPropertyBindingResult(properties, "properties");
    properties.validate(properties, errors);
    replacedertThat(errors.getFieldError("profileSeparator")).isNull();
}

@ParameterizedTest
@MethodSource("invalidProperties")
public void validationFails(AwsParamStoreProperties properties, String field, String errorCode) {
    Errors errors = new BeanPropertyBindingResult(properties, "properties");
    properties.validate(properties, errors);
    replacedertThat(errors.getFieldError(field)).isNotNull();
    replacedertThat(errors.getFieldError(field).getCode()).isEqualTo(errorCode);
}

@Test
void acceptsBackslashAsProfileSeparator() {
    AwsParamStoreProperties properties = new AwsParamStoreProperties();
    properties.setProfileSeparator("\\");
    Errors errors = new BeanPropertyBindingResult(properties, "properties");
    properties.validate(properties, errors);
    replacedertThat(errors.getFieldError("profileSeparator")).isNull();
}

@Test
public void testRequiredFields() {
    StartLaunchRQ startLaunchRQ = new StartLaunchRQ();
    startLaunchRQ.setDescription("some description");
    startLaunchRQ.setName("some launch name");
    startLaunchRQ.setAttributes(Collections.emptySet());
    JaskonRequiredPropertiesValidator validator = new JaskonRequiredPropertiesValidator();
    Errors errors = new BeanPropertyBindingResult(startLaunchRQ, "startLaunchRq");
    validator.validate(startLaunchRQ, errors);
    replacedertThat(errors.getAllErrors(), not(empty()));
    replacedertThat(errors.getFieldError("startTime"), not(nullValue()));
}

/**
 * @see ProviderValidator#validate(Object, Errors)
 */
@Test
public void validate_shouldBeInvalidIfProviderIsRetiredAndTheRetiredReasonIsNotMentioned() {
    provider.setIdentifier("id");
    provider.setRetired(true);
    provider.setPerson(new Person());
    providerValidator.validate(provider, errors);
    replacedert.replacedertTrue(errors.hasErrors());
    replacedert.replacedertTrue(errors.hasFieldErrors("retireReason"));
    replacedert.replacedertEquals("Provider.error.retireReason.required", errors.getFieldError("retireReason").getCode());
    errors = new BindException(provider, "provider");
    provider.setRetireReason("getting old..");
    providerValidator.validate(provider, errors);
    replacedert.replacedertFalse(errors.hasErrors());
}

/**
 * @see OrderValidator#validate(Object, org.springframework.validation.Errors)
 */
@Test
public void validate_shouldFailValidationIfOrderTypejavaClreplacedDoesNotMatchOrderclreplaced() {
    Order order = new DrugOrder();
    order.setConcept(Context.getConceptService().getConcept(88));
    order.setPatient(Context.getPatientService().getPatient(2));
    order.setOrderer(Context.getProviderService().getProvider(1));
    order.setOrderType(Context.getOrderService().getOrderTypeByName("Test order"));
    Errors errors = new BindException(order, "order");
    new OrderValidator().validate(order, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("orderType"));
    replacedert.replacedertTrue(Arrays.asList(errors.getFieldError("orderType").getCodes()).contains("Order.error.orderTypeClreplacedMismatchesOrderClreplaced"));
}

/**
 * @see EncounterValidator#validate(Object,Errors)
 */
@Test
public void validate_shouldFailIfThePatientsForTheVisitAndTheEncounterDontMatch() {
    encounter.setPatient(new Patient(2));
    Visit visit = new Visit();
    visit.setPatient(new Patient(3));
    encounter.setVisit(visit);
    encounterValidator.validate(encounter, errors);
    replacedert.replacedertEquals("Encounter.visit.patients.dontMatch", errors.getFieldError("visit").getCode());
}

/**
 * @see EncounterValidator#validate(Object,Errors)
 */
@Test
public void validate_shouldFailIfTheVisitHasNoPatient() {
    encounter.setPatient(new Patient(2));
    Visit visit = new Visit();
    encounter.setVisit(visit);
    encounterValidator.validate(encounter, errors);
    replacedert.replacedertEquals("Encounter.visit.patients.dontMatch", errors.getFieldError("visit").getCode());
}

// API: Update post
@PutMapping("/{id}")
@ResponseBody
@Transactional
public JSONReplyDTO update(@PathVariable("id") Post post, @Valid @RequestBody PostForm postForm, Errors errors) {
    if (errors.hasFieldErrors()) {
        FieldError error = errors.getFieldError();
        return JSONReplyDTO.fail(error.getField() + ": " + error.getDefaultMessage());
    }
    postService.update(post, postForm);
    return JSONReplyDTO.success("Updated successfully");
}

See More Examples