org.springframework.validation.Errors.hasFieldErrors()

/**
 * @see OrderValidator#validate(Object,Errors)
 */
@Test
public void validate_shouldFailValidationIfConceptIsNull() {
    Order order = new Order();
    order.setPatient(Context.getPatientService().getPatient(2));
    order.setOrderer(Context.getProviderService().getProvider(1));
    Errors errors = new BindException(order, "order");
    new OrderValidator().validate(order, errors);
    replacedert.replacedertFalse(errors.hasFieldErrors("discontinued"));
    replacedert.replacedertTrue(errors.hasFieldErrors("concept"));
    replacedert.replacedertFalse(errors.hasFieldErrors("patient"));
    replacedert.replacedertFalse(errors.hasFieldErrors("orderer"));
}

@Test
void rejectsFieldByMethodReference() {
    createPayload(new Payload()).rejectField("someField", "error.code").peekErrors(errors -> {
        replacedertThat(errors.hasFieldErrors("someField")).isTrue();
    });
}

/**
 * @see OrderValidator#validate(Object,Errors)
 */
@Test
public void validate_shouldFailValidationIfUrgencyIsNull() {
    Order order = new Order();
    order.setConcept(Context.getConceptService().getConcept(88));
    order.setPatient(Context.getPatientService().getPatient(2));
    order.setUrgency(null);
    Errors errors = new BindException(order, "order");
    new OrderValidator().validate(order, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("urgency"));
}

/**
 * @see OrderValidator#validate(Object, org.springframework.validation.Errors)
 */
@Test
public void validate_shouldFailValidationIfScheduledDateIsNullWhenUrgencyIsON_SCHEDULED_DATE() {
    Order order = new Order();
    order.setConcept(Context.getConceptService().getConcept(88));
    order.setPatient(Context.getPatientService().getPatient(2));
    order.setOrderer(Context.getProviderService().getProvider(1));
    order.setUrgency(Order.Urgency.ON_SCHEDULED_DATE);
    order.setScheduledDate(null);
    Errors errors = new BindException(order, "order");
    new OrderValidator().validate(order, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("scheduledDate"));
    order.setScheduledDate(new Date());
    order.setUrgency(Order.Urgency.STAT);
    errors = new BindException(order, "order");
    new OrderValidator().validate(order, errors);
    replacedert.replacedertFalse(errors.hasFieldErrors("scheduledDate"));
}

/**
 * @see OrderValidator#validate(Object,Errors)
 */
@Test
public void validate_shouldFailValidationIfOrdererIsNull() {
    Order order = new Order();
    order.setConcept(Context.getConceptService().getConcept(88));
    order.setPatient(Context.getPatientService().getPatient(2));
    Errors errors = new BindException(order, "order");
    new OrderValidator().validate(order, errors);
    replacedert.replacedertFalse(errors.hasFieldErrors("discontinued"));
    replacedert.replacedertFalse(errors.hasFieldErrors("concept"));
    replacedert.replacedertTrue(errors.hasFieldErrors("orderer"));
    replacedert.replacedertFalse(errors.hasFieldErrors("patient"));
}

/**
 * @see OrderValidator#validate(Object,Errors)
 */
@Test
public void validate_shouldFailValidationIfActionIsNull() {
    Order order = new Order();
    order.setConcept(Context.getConceptService().getConcept(88));
    order.setPatient(Context.getPatientService().getPatient(2));
    order.setAction(null);
    Errors errors = new BindException(order, "order");
    new OrderValidator().validate(order, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("action"));
}

/**
 * @see OrderValidator#validate(Object, org.springframework.validation.Errors)
 */
@Test
public void validate_shouldFailValidationIfScheduledDateIsSetAndUrgencyIsNotSetAsON_SCHEDULED_DATE() {
    Order order = new Order();
    order.setConcept(Context.getConceptService().getConcept(88));
    order.setPatient(Context.getPatientService().getPatient(2));
    order.setOrderer(Context.getProviderService().getProvider(1));
    order.setScheduledDate(new Date());
    order.setUrgency(Order.Urgency.ROUTINE);
    Errors errors = new BindException(order, "order");
    new OrderValidator().validate(order, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("urgency"));
    order.setScheduledDate(new Date());
    order.setUrgency(Order.Urgency.ON_SCHEDULED_DATE);
    errors = new BindException(order, "order");
    new OrderValidator().validate(order, errors);
    replacedert.replacedertFalse(errors.hasFieldErrors("urgency"));
}

/**
 * @see OrderValidator#validate(Object,Errors)
 */
@Test
public void validate_shouldFailValidationIfVoidedIsNull() {
    Order order = new Order();
    order.setVoided(null);
    order.setConcept(Context.getConceptService().getConcept(88));
    order.setPatient(Context.getPatientService().getPatient(2));
    order.setOrderer(Context.getProviderService().getProvider(1));
    Errors errors = new BindException(order, "order");
    new OrderValidator().validate(order, errors);
    replacedert.replacedertFalse(errors.hasFieldErrors("discontinued"));
    replacedert.replacedertTrue(errors.hasFieldErrors("voided"));
    replacedert.replacedertFalse(errors.hasFieldErrors("concept"));
    replacedert.replacedertFalse(errors.hasFieldErrors("patient"));
    replacedert.replacedertFalse(errors.hasFieldErrors("orderer"));
}

/**
 * @see OrderValidator#validate(Object,Errors)
 */
@Test
public void validate_shouldFailValidationIfPatientIsNull() {
    Order order = new Order();
    order.setConcept(Context.getConceptService().getConcept(88));
    order.setOrderer(Context.getProviderService().getProvider(1));
    Errors errors = new BindException(order, "order");
    new OrderValidator().validate(order, errors);
    replacedert.replacedertFalse(errors.hasFieldErrors("discontinued"));
    replacedert.replacedertFalse(errors.hasFieldErrors("concept"));
    replacedert.replacedertTrue(errors.hasFieldErrors("patient"));
    replacedert.replacedertFalse(errors.hasFieldErrors("orderer"));
}

/**
 * @see DrugOrderValidator#validate(Object,Errors)
 */
@Test
public void validate_shouldNotFailValidationIfDrugIsNull() {
    DrugOrder order = new DrugOrder();
    order.setDrug(null);
    Errors errors = new BindException(order, "order");
    new DrugOrderValidator().validate(order, errors);
    replacedert.replacedertFalse(errors.hasFieldErrors("drug"));
}

/**
 * @see DrugOrderValidator#validate(Object, org.springframework.validation.Errors)
 */
@Test
public void validate_shouldFailIfConceptIsNullAndDrugIsNotSpecified() {
    DrugOrder order = new DrugOrder();
    Errors errors = new BindException(order, "order");
    new DrugOrderValidator().validate(order, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("concept"));
}

private void replacedertThatFieldTextHasError() {
    replacedert.replacedertTrue(errors.hasFieldErrors("text"));
}

/**
 * @see ProviderValidator#validate(Object, Errors)
 */
@Test
public void validate_shouldBeValidIfIdentifierIsSet() {
    // given
    provider.setIdentifier("id");
    // when
    providerValidator.validate(provider, errors);
    // then
    replacedert.replacedertFalse(errors.hasFieldErrors("identifier"));
}

/**
 * @see OrderValidator#validate(Object,Errors)
 */
@Test
public void validate_shouldFailValidationIfEncounterIsNull() {
    Order order = new Order();
    order.setConcept(Context.getConceptService().getConcept(88));
    order.setPatient(Context.getPatientService().getPatient(2));
    order.setEncounter(null);
    Errors errors = new BindException(order, "order");
    new OrderValidator().validate(order, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("encounter"));
}

/**
 * @see OrderValidator#validate(Object, org.springframework.validation.Errors)
 */
@Test
public void validate_shouldPreplacedValidationIfTheClreplacedOfTheOrderIsASubclreplacedOfOrderTypejavaClreplaced() {
    SomeDrugOrder order = new SomeDrugOrder();
    order.setConcept(Context.getConceptService().getConcept(88));
    order.setPatient(Context.getPatientService().getPatient(2));
    order.setOrderer(Context.getProviderService().getProvider(1));
    order.setOrderType(Context.getOrderService().getOrderTypeByName("Drug order"));
    Errors errors = new BindException(order, "order");
    new OrderValidator().validate(order, errors);
    replacedert.replacedertFalse(errors.hasFieldErrors("orderType"));
}

/**
 * @see OrderValidator#validate(Object,Errors)
 */
@Test
public void validate_shouldFailValidationIfOrderAndEncounterHaveDifferentPatients() {
    Order order = new Order();
    order.setConcept(Context.getConceptService().getConcept(88));
    order.setPatient(Context.getPatientService().getPatient(2));
    order.setEncounter(Context.getEncounterService().getEncounter(3));
    order.setOrderer(Context.getProviderService().getProvider(1));
    Errors errors = new BindException(order, "order");
    new OrderValidator().validate(order, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("encounter"));
}

/**
 * @throws Exception
 * @see OrderValidator#validate(Object,Errors)
 */
@Test
public void validate_shouldFailValidationIfDateActivatedAfterDateStopped() throws Exception {
    Order order = new Order();
    order.setConcept(Context.getConceptService().getConcept(88));
    order.setPatient(Context.getPatientService().getPatient(2));
    order.setOrderer(Context.getProviderService().getProvider(1));
    Calendar cal = Calendar.getInstance();
    cal.set(Calendar.DAY_OF_MONTH, cal.get(Calendar.DAY_OF_MONTH) - 1);
    order.setDateActivated(new Date());
    OrderUtilTest.setDateStopped(order, cal.getTime());
    Errors errors = new BindException(order, "order");
    new OrderValidator().validate(order, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("dateActivated"));
    replacedert.replacedertTrue(errors.hasFieldErrors("dateStopped"));
}

/**
 * @see EncounterValidator#validate(Object, org.springframework.validation.Errors)
 */
@Test
public void validate_shouldFailIfEncounterTypeIsNotSet() {
    encounterValidator.validate(encounter, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("encounterType"));
}

/**
 * @see EncounterValidator#validate(Object,Errors)
 */
@Test
public void validate_shouldFailIfPatientIsNotSet() {
    encounterValidator.validate(encounter, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("patient"));
}

/**
 * @see EncounterValidator#validate(Object, org.springframework.validation.Errors)
 */
@Test
public void validate_shouldFailIfEncounterDateTimeIsNotSet() {
    encounterValidator.validate(encounter, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("encounterDatetime"));
}

/**
 * @see DrugOrderValidator#validate(Object, org.springframework.validation.Errors)
 */
@Test
public void validate_shouldFailValidationIfDoseUnitsIsNullForSimpleDosingInstructionsDosingType() {
    DrugOrder order = new DrugOrder();
    order.setDosingType(SimpleDosingInstructions.clreplaced);
    order.setDoseUnits(null);
    Errors errors = new BindException(order, "order");
    new DrugOrderValidator().validate(order, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("doseUnits"));
}

/**
 * @see DrugOrderValidator#validate(Object, org.springframework.validation.Errors)
 */
@Test
public void validate_shouldFailValidationIfDoseIsNullForSimpleDosingInstructionsDosingType() {
    DrugOrder order = new DrugOrder();
    order.setDosingType(SimpleDosingInstructions.clreplaced);
    order.setDose(null);
    Errors errors = new BindException(order, "order");
    new DrugOrderValidator().validate(order, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("dose"));
}

/**
 * @see DrugOrderValidator#validate(Object,Errors)
 */
@Test
public void validate_shouldFailValidationIfAsNeededIsNull() {
    DrugOrder order = new DrugOrder();
    order.setAsNeeded(null);
    order.setDrug(Context.getConceptService().getDrug(3));
    Errors errors = new BindException(order, "order");
    new DrugOrderValidator().validate(order, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("asNeeded"));
}

/**
 * @see DrugOrderValidator#validate(Object, org.springframework.validation.Errors)
 */
@Test
public void validate_shouldNotValidateACustomDosingTypeAgainstAnyOtherDosingTypeValidation() {
    DrugOrder order = new DrugOrder();
    order.setDosingType(CustomDosingInstructions.clreplaced);
    order.setDosingInstructions(null);
    Errors errors = new BindException(order, "order");
    new DrugOrderValidator().validate(order, errors);
    replacedert.replacedertFalse(errors.hasFieldErrors("dosingInstructions"));
}

/**
 * @see DrugOrderValidator#validate(Object, org.springframework.validation.Errors)
 */
@Test
public void validate_shouldFailValidationIfDosingInstructionsIsNullForFreeTextDosingInstructionsDosingType() {
    DrugOrder order = new DrugOrder();
    order.setDosingType(FreeTextDosingInstructions.clreplaced);
    order.setDosingInstructions(null);
    Errors errors = new BindException(order, "order");
    new DrugOrderValidator().validate(order, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("dosingInstructions"));
}

/**
 * @see DrugOrderValidator#validate(Object, org.springframework.validation.Errors)
 */
@Test
public void validate_shouldFailValidationIfDoseUnitsIsNullWhenDoseIsPresent() {
    DrugOrder order = new DrugOrder();
    order.setDosingType(FreeTextDosingInstructions.clreplaced);
    order.setDose(20.0);
    order.setDoseUnits(null);
    Errors errors = new BindException(order, "order");
    new DrugOrderValidator().validate(order, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("doseUnits"));
}

@Test
public void validate_shouldFailValidationIfCertaintyIsNull() {
    diagnosis.setCertainty(null);
    new DiagnosisValidator().validate(diagnosis, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("certainty"));
}

@Test
public void validate_shouldFailValidationIfDiagnosisIsNull() {
    diagnosis.setDiagnosis(null);
    new DiagnosisValidator().validate(diagnosis, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("diagnosis"));
}

@Test
public void shouldFailIfGivenConditionWithNullConditionProperties() {
    Condition condition = new Condition();
    validator.validate(condition, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("condition"));
    replacedert.replacedertTrue(errors.hasFieldErrors("clinicalStatus"));
}

private void replacedertThatFieldExceedsMaxLength(String field) {
    replacedert.replacedertTrue(String.format("Field '%s' has error(s)", field), errors.hasFieldErrors(field));
    replacedertThat(errors.getFieldErrors(field).get(0).getCode(), is("error.exceededMaxLengthOfField"));
}

@Test
public void validate_shouldPreplacedIfPatientIsNonVoided() {
    validator.validate(cohort, errors);
    replacedert.replacedertFalse(errors.hasErrors());
    replacedert.replacedertFalse(errors.hasFieldErrors("memberships"));
}

@Test
public void validate_shouldPreplacedIfMembershipisVoided() {
    cohortMembership.setVoided(true);
    validator.validate(cohort, errors);
    replacedert.replacedertFalse(errors.hasErrors());
    replacedert.replacedertFalse(errors.hasFieldErrors("memberships"));
}

/**
 * @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"));
}

/**
 * @see org.openmrs.validator.PersonValidator#validate(Object,Errors)
 */
@Test
public void validate_shouldPreplacedValidationIfGenderIsBlankForPersons() {
    Person person = new Person(1);
    Errors errors = new BindException(person, "person");
    PersonValidator personValidator = new PersonValidator();
    personValidator.validate(person, errors);
    replacedert.replacedertFalse(errors.hasFieldErrors("gender"));
}

/**
 * @see PersonMergeLogValidator#validate(Object,Errors)
 */
@Test
public void validate_shouldPreplacedValidationIfAllFieldsAreCorrect() {
    PersonMergeLog personMergeLog = new PersonMergeLog();
    personMergeLog.setWinner(new Person());
    personMergeLog.setLoser(new Person());
    personMergeLog.setPersonMergeLogData(new PersonMergeLogData());
    PersonMergeLogValidator validator = new PersonMergeLogValidator();
    Errors errors = new BindException(personMergeLog, "personMergeLog");
    validator.validate(personMergeLog, errors);
    replacedert.replacedertFalse(errors.hasFieldErrors());
}

/**
 * @see org.openmrs.validator.PatientValidator#validate(Object,Errors)
 */
@Test
public void validate_shouldFailValidationIfGenderIsBlank() {
    Patient pa = new Patient(1);
    Errors errors = new BindException(pa, "patient");
    validator.validate(pa, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("gender"));
}

/**
 * @see OrderValidator#validate(Object,Errors)
 */
@Test
public void validate_shouldFailValidationIfDateActivatedAfterAutoExpireDate() {
    Order order = new Order();
    order.setConcept(Context.getConceptService().getConcept(88));
    order.setPatient(Context.getPatientService().getPatient(2));
    order.setOrderer(Context.getProviderService().getProvider(1));
    Calendar cal = Calendar.getInstance();
    cal.set(Calendar.DAY_OF_MONTH, cal.get(Calendar.DAY_OF_MONTH) - 1);
    order.setDateActivated(new Date());
    order.setAutoExpireDate(cal.getTime());
    Errors errors = new BindException(order, "order");
    new OrderValidator().validate(order, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("dateActivated"));
    replacedert.replacedertTrue(errors.hasFieldErrors("autoExpireDate"));
}

@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 OrderValidator#validate(Object, org.springframework.validation.Errors)
 */
@Test
public void validate_shouldFailValidationIfDateActivatedIsBeforeEncountersEncounterDatetime() {
    Date encounterDate = new Date();
    Date orderDate = DateUtils.addDays(encounterDate, -1);
    Encounter encounter = Context.getEncounterService().getEncounter(3);
    encounter.setEncounterDatetime(encounterDate);
    Order order = new Order();
    order.setDateActivated(orderDate);
    order.setConcept(Context.getConceptService().getConcept(88));
    order.setPatient(Context.getPatientService().getPatient(2));
    order.setEncounter(encounter);
    order.setOrderer(Context.getProviderService().getProvider(1));
    Errors errors = new BindException(order, "order");
    new OrderValidator().validate(order, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("dateActivated"));
}

/**
 * @see DrugOrderValidator#validate(Object,Errors)
 */
@Test
public void validate_shouldFailValidationIfDosingTypeIsNull() {
    DrugOrder order = new DrugOrder();
    order.setDosingType(null);
    order.setDrug(Context.getConceptService().getDrug(3));
    Errors errors = new BindException(order, "order");
    new DrugOrderValidator().validate(order, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("dosingType"));
}

/**
 * @see DrugOrderValidator#validate(Object, org.springframework.validation.Errors)
 */
@Test
public void validate_shouldFailValidationIfRouteIsNullForSimpleDosingInstructionsDosingType() {
    DrugOrder order = new DrugOrder();
    order.setDosingType(SimpleDosingInstructions.clreplaced);
    order.setRoute(null);
    Errors errors = new BindException(order, "order");
    new DrugOrderValidator().validate(order, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("route"));
}

/**
 * @see DrugOrderValidator#validate(Object, org.springframework.validation.Errors)
 */
@Test
public void validate_shouldFailValidationIfNumberOfRefillsIsNullForOutpatientCareSetting() {
    DrugOrder OutpatientOrder = new DrugOrder();
    OutpatientOrder.setCareSetting(Context.getOrderService().getCareSetting(1));
    OutpatientOrder.setNumRefills(null);
    Errors OutpatientOrderErrors = new BindException(OutpatientOrder, "order");
    new DrugOrderValidator().validate(OutpatientOrder, OutpatientOrderErrors);
    replacedert.replacedertTrue(OutpatientOrderErrors.hasFieldErrors("numRefills"));
    DrugOrder inPatientOrder = new DrugOrder();
    inPatientOrder.setCareSetting(Context.getOrderService().getCareSetting(2));
    inPatientOrder.setNumRefills(null);
    Errors InpatientOrderErrors = new BindException(inPatientOrder, "order");
    new DrugOrderValidator().validate(inPatientOrder, InpatientOrderErrors);
    replacedert.replacedertFalse(InpatientOrderErrors.hasFieldErrors("numRefills"));
}

/**
 * @see DrugOrderValidator#validate(Object, org.springframework.validation.Errors)
 */
@Test
public void validate_shouldFailValidationIfDurationUnitsIsNullWhenDurationIsPresent() {
    DrugOrder order = new DrugOrder();
    order.setDosingType(FreeTextDosingInstructions.clreplaced);
    order.setDuration(20);
    order.setDurationUnits(null);
    Errors errors = new BindException(order, "order");
    new DrugOrderValidator().validate(order, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("durationUnits"));
}

/**
 * @see DrugOrderValidator#validate(Object, org.springframework.validation.Errors)
 */
@Test
public void validate_shouldFailValidationIfFrequencyIsNullForSimpleDosingInstructionsDosingType() {
    DrugOrder order = new DrugOrder();
    order.setDosingType(SimpleDosingInstructions.clreplaced);
    order.setFrequency(null);
    Errors errors = new BindException(order, "order");
    new DrugOrderValidator().validate(order, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("frequency"));
}

/**
 * @see DiagnosisValidator#validate(Object, Errors)
 */
@Test
public void validate_shouldFailValidationIfEncounterIsNull() {
    diagnosis.setEncounter(null);
    new DiagnosisValidator().validate(diagnosis, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("encounter"));
}

@Test
public void validate_shouldFailValidationIfRankIsNonPositive() {
    diagnosis.setRank(-1);
    new DiagnosisValidator().validate(diagnosis, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("rank"));
}

@Test
public void validate_shouldFailValidationIfRankIsNull() {
    diagnosis.setRank(null);
    new DiagnosisValidator().validate(diagnosis, errors);
    replacedert.replacedertTrue(errors.hasFieldErrors("rank"));
}

@Test
public void shouldPreplacedIfConditionClreplacedIsPreplacededWithRequiredConditionProperties() {
    Condition condition = new Condition();
    condition.setCondition(new CodedOrFreeText(new Concept(), new ConceptName("name", new Locale("en")), "nonCoded"));
    condition.setClinicalStatus(ConditionClinicalStatus.ACTIVE);
    validator.validate(condition, errors);
    replacedert.replacedertFalse(errors.hasFieldErrors("condition"));
    replacedert.replacedertFalse(errors.hasFieldErrors("clinicalStatus"));
}

@Test
public void validate_shouldPreplacedValidationIfDescriptionIsNullOrEmptyOrWhitespace() {
    ConceptClreplaced cc = new ConceptClreplaced();
    cc.setName("name");
    cc.setDescription(null);
    Errors errors = new BindException(cc, "cc");
    new ConceptClreplacedValidator().validate(cc, errors);
    replacedert.replacedertFalse(errors.hasFieldErrors("description"));
    cc.setDescription("");
    errors = new BindException(cc, "cc");
    new ConceptClreplacedValidator().validate(cc, errors);
    replacedert.replacedertFalse(errors.hasFieldErrors("description"));
    cc.setDescription(" ");
    errors = new BindException(cc, "cc");
    new ConceptClreplacedValidator().validate(cc, errors);
    replacedert.replacedertFalse(errors.hasFieldErrors("description"));
}

See More Examples