You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@struts.apache.org by lu...@apache.org on 2017/04/19 07:42:18 UTC
[04/13] struts git commit: WW-4578 Converts double range validator to
support collections
WW-4578 Converts double range validator to support collections
Project: http://git-wip-us.apache.org/repos/asf/struts/repo
Commit: http://git-wip-us.apache.org/repos/asf/struts/commit/01a56ca1
Tree: http://git-wip-us.apache.org/repos/asf/struts/tree/01a56ca1
Diff: http://git-wip-us.apache.org/repos/asf/struts/diff/01a56ca1
Branch: refs/heads/master
Commit: 01a56ca117532c63a89bec6464109e81d9273d62
Parents: e66fd53
Author: Lukasz Lenart <lu...@apache.org>
Authored: Mon Apr 10 21:54:03 2017 +0200
Committer: Lukasz Lenart <lu...@apache.org>
Committed: Mon Apr 10 21:54:03 2017 +0200
----------------------------------------------------------------------
.../validators/DoubleRangeFieldValidator.java | 73 ++--
.../DoubleRangeFieldValidatorTest.java | 363 +++++++++++++++++++
.../validator/DoubleRangeValidatorTest.java | 279 --------------
3 files changed, 413 insertions(+), 302 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/struts/blob/01a56ca1/core/src/main/java/com/opensymphony/xwork2/validator/validators/DoubleRangeFieldValidator.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/com/opensymphony/xwork2/validator/validators/DoubleRangeFieldValidator.java b/core/src/main/java/com/opensymphony/xwork2/validator/validators/DoubleRangeFieldValidator.java
index 8ed4e4c..f968b97 100644
--- a/core/src/main/java/com/opensymphony/xwork2/validator/validators/DoubleRangeFieldValidator.java
+++ b/core/src/main/java/com/opensymphony/xwork2/validator/validators/DoubleRangeFieldValidator.java
@@ -18,6 +18,11 @@ package com.opensymphony.xwork2.validator.validators;
import com.opensymphony.xwork2.validator.ValidationException;
import org.apache.commons.lang3.StringUtils;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.Arrays;
+import java.util.Collection;
/**
* <!-- START SNIPPET: javadoc -->
@@ -27,15 +32,15 @@ import org.apache.commons.lang3.StringUtils;
*
* <!-- START SNIPPET: parameters -->
* <ul>
- * <li>fieldName - The field name this validator is validating. Required if using Plain-Validator Syntax otherwise not required</li>
- * <li>minInclusive - the minimum inclusive value in FloatValue format specified by Java language (if none is specified, it will not be checked) </li>
- * <li>maxInclusive - the maximum inclusive value in FloatValue format specified by Java language (if none is specified, it will not be checked) </li>
- * <li>minExclusive - the minimum exclusive value in FloatValue format specified by Java language (if none is specified, it will not be checked) </li>
- * <li>maxExclusive - the maximum exclusive value in FloatValue format specified by Java language (if none is specified, it will not be checked) </li>
- * <li>minInclusiveExpression - the minimum inclusive value specified as a OGNL expression (if none is specified, it will not be checked) </li>
- * <li>maxInclusiveExpression - the maximum inclusive value specified as a OGNL expression (if none is specified, it will not be checked) </li>
- * <li>minExclusiveExpression - the minimum exclusive value specified as a OGNL expression (if none is specified, it will not be checked) </li>
- * <li>maxExclusiveExpression - the maximum exclusive value specified as a OGNL expression (if none is specified, it will not be checked) </li>
+ * <li>fieldName - The field name this validator is validating. Required if using Plain-Validator Syntax otherwise not required</li>
+ * <li>minInclusive - the minimum inclusive value in FloatValue format specified by Java language (if none is specified, it will not be checked) </li>
+ * <li>maxInclusive - the maximum inclusive value in FloatValue format specified by Java language (if none is specified, it will not be checked) </li>
+ * <li>minExclusive - the minimum exclusive value in FloatValue format specified by Java language (if none is specified, it will not be checked) </li>
+ * <li>maxExclusive - the maximum exclusive value in FloatValue format specified by Java language (if none is specified, it will not be checked) </li>
+ * <li>minInclusiveExpression - the minimum inclusive value specified as a OGNL expression (if none is specified, it will not be checked) </li>
+ * <li>maxInclusiveExpression - the maximum inclusive value specified as a OGNL expression (if none is specified, it will not be checked) </li>
+ * <li>minExclusiveExpression - the minimum exclusive value specified as a OGNL expression (if none is specified, it will not be checked) </li>
+ * <li>maxExclusiveExpression - the maximum exclusive value specified as a OGNL expression (if none is specified, it will not be checked) </li>
* </ul>
*
* You can specify either minInclusive, maxInclusive, minExclusive and maxExclusive or minInclusiveExpression, maxInclusiveExpression,
@@ -86,7 +91,9 @@ import org.apache.commons.lang3.StringUtils;
* @author Rene Gielen
*/
public class DoubleRangeFieldValidator extends FieldValidatorSupport {
-
+
+ private static final Logger LOG = LogManager.getLogger(DoubleRangeFieldValidator.class);
+
private Double maxInclusive = null;
private Double minInclusive = null;
private Double minExclusive = null;
@@ -99,14 +106,8 @@ public class DoubleRangeFieldValidator extends FieldValidatorSupport {
public void validate(Object object) throws ValidationException {
String fieldName = getFieldName();
- Double value;
- try {
- Object obj = this.getFieldValue(fieldName, object);
- if (obj == null) {
- return;
- }
- value = Double.valueOf(obj.toString());
- } catch (NumberFormatException e) {
+ Object obj = this.getFieldValue(fieldName, object);
+ if (obj == null) {
return;
}
@@ -115,11 +116,37 @@ public class DoubleRangeFieldValidator extends FieldValidatorSupport {
Double maxExclusiveToUse = getMaxExclusive();
Double minExclusiveToUse = getMinExclusive();
- if ((maxInclusiveToUse != null && value.compareTo(maxInclusiveToUse) > 0) ||
- (minInclusiveToUse != null && value.compareTo(minInclusiveToUse) < 0) ||
- (maxExclusiveToUse != null && value.compareTo(maxExclusiveToUse) >= 0) ||
- (minExclusiveToUse != null && value.compareTo(minExclusiveToUse) <= 0)) {
- addFieldError(fieldName, object);
+ if (obj.getClass().isArray()) {
+ Object[] values = (Object[]) obj;
+ validateCollection(maxInclusiveToUse, minInclusiveToUse, maxExclusiveToUse, minExclusiveToUse, Arrays.asList(values));
+ } else if (Collection.class.isAssignableFrom(obj.getClass())) {
+ Collection values = (Collection) obj;
+ validateCollection(maxInclusiveToUse, minInclusiveToUse, maxExclusiveToUse, minExclusiveToUse, values);
+ } else {
+ validateValue(obj, maxInclusiveToUse, minInclusiveToUse, maxExclusiveToUse, minExclusiveToUse);
+ }
+ }
+
+ protected void validateCollection(Double maxInclusiveToUse, Double minInclusiveToUse, Double maxExclusiveToUse, Double minExclusiveToUse, Collection values) {
+ for (Object objValue : values) {
+ validateValue(objValue, maxInclusiveToUse, minInclusiveToUse, maxExclusiveToUse, minExclusiveToUse);
+ }
+ }
+
+ protected void validateValue(Object obj, Double maxInclusiveToUse, Double minInclusiveToUse, Double maxExclusiveToUse, Double minExclusiveToUse) {
+ try {
+ setCurrentValue(obj);
+ Double value = Double.valueOf(obj.toString());
+ if ((maxInclusiveToUse != null && value.compareTo(maxInclusiveToUse) > 0) ||
+ (minInclusiveToUse != null && value.compareTo(minInclusiveToUse) < 0) ||
+ (maxExclusiveToUse != null && value.compareTo(maxExclusiveToUse) >= 0) ||
+ (minExclusiveToUse != null && value.compareTo(minExclusiveToUse) <= 0)) {
+ addFieldError(getFieldName(), value);
+ }
+ } catch (NumberFormatException e) {
+ LOG.debug("Cannot validate value {} - not a Double", e);
+ } finally {
+ setCurrentValue(null);
}
}
http://git-wip-us.apache.org/repos/asf/struts/blob/01a56ca1/core/src/test/java/com/opensymphony/xwork2/validator/DoubleRangeFieldValidatorTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/com/opensymphony/xwork2/validator/DoubleRangeFieldValidatorTest.java b/core/src/test/java/com/opensymphony/xwork2/validator/DoubleRangeFieldValidatorTest.java
new file mode 100644
index 0000000..68b1a82
--- /dev/null
+++ b/core/src/test/java/com/opensymphony/xwork2/validator/DoubleRangeFieldValidatorTest.java
@@ -0,0 +1,363 @@
+package com.opensymphony.xwork2.validator;
+
+import com.opensymphony.xwork2.ActionContext;
+import com.opensymphony.xwork2.ActionProxy;
+import com.opensymphony.xwork2.ActionSupport;
+import com.opensymphony.xwork2.TextProviderFactory;
+import com.opensymphony.xwork2.ValidationAwareSupport;
+import com.opensymphony.xwork2.XWorkTestCase;
+import com.opensymphony.xwork2.config.providers.MockConfigurationProvider;
+import com.opensymphony.xwork2.config.providers.XmlConfigurationProvider;
+import com.opensymphony.xwork2.interceptor.ValidationAware;
+import com.opensymphony.xwork2.util.ValueStack;
+import com.opensymphony.xwork2.validator.validators.DoubleRangeFieldValidator;
+import org.apache.struts2.dispatcher.HttpParameters;
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Unit test for {@link DoubleRangeFieldValidator}.
+ *
+ * @author <a href="mailto:hermanns@aixcept.de">Rainer Hermanns</a>
+ * @author Claus Ibsen
+ * @version $Id$
+ */
+public class DoubleRangeFieldValidatorTest extends XWorkTestCase {
+
+ private DoubleRangeFieldValidator val;
+ private TextProviderFactory tpf;
+
+ public void testRangeValidationWithError() throws Exception {
+ //Explicitly set an out-of-range double for DoubleRangeValidatorTest
+ Map<String, Object> context = new HashMap<>();
+ HashMap<String, Object> params = new HashMap<>();
+ params.put("percentage", 100.0123d);
+ context.put(ActionContext.PARAMETERS, HttpParameters.create(params).build());
+
+ ActionProxy proxy = actionProxyFactory.createActionProxy("", MockConfigurationProvider.VALIDATION_ACTION_NAME, null, context);
+ proxy.execute();
+ assertTrue(((ValidationAware) proxy.getAction()).hasFieldErrors());
+
+ Map<String, List<String>> errors = ((ValidationAware) proxy.getAction()).getFieldErrors();
+
+ List<String> errorMessages = errors.get("percentage");
+ assertNotNull("Expected double range validation error message.", errorMessages);
+ assertEquals(1, errorMessages.size());
+
+ String errorMessage = errorMessages.get(0);
+ assertNotNull("Expecting: percentage must be between 0.1 and 10.1, current value is 100.0123.", errorMessage);
+ assertEquals("percentage must be between 0.1 and 10.1, current value is 100.0123.", errorMessage);
+ }
+
+ public void testRangeValidationNoError() throws Exception {
+ Map<String, Object> context = new HashMap<>();
+ HashMap<String, Object> params = new HashMap<>();
+ params.put("percentage", 1.234567d);
+ context.put(ActionContext.PARAMETERS, HttpParameters.create(params).build());
+
+ ActionProxy proxy = actionProxyFactory.createActionProxy("", "percentage", null, context);
+ proxy.execute();
+ assertTrue(((ValidationAware) proxy.getAction()).hasFieldErrors());
+
+ Map<String, List<String>> errors = ((ValidationAware) proxy.getAction()).getFieldErrors();
+ List<String> errorMessages = errors.get("percentage");
+ assertNull("Expected no double range validation error message.", errorMessages);
+ }
+
+ public void testRangeNoExclusiveAndNoValueInStack() throws Exception {
+ val.setFieldName("hello");
+ val.validate("world");
+ }
+
+ public void testRangeSimpleDoubleValueInStack() throws Exception {
+ MyTestProduct prod = new MyTestProduct();
+ prod.setName("coca cola");
+ prod.setPrice(5.99);
+
+ ValueStack stack = ActionContext.getContext().getValueStack();
+ stack.push(prod);
+ ActionContext.getContext().setValueStack(stack);
+
+ val.setMinInclusive(0d);
+ val.setMaxInclusive(10d);
+ val.setFieldName("price");
+ val.validate(prod);
+ }
+
+ public void testRangeRealDoubleValueInStack() throws Exception {
+ MyTestProduct prod = new MyTestProduct();
+ prod.setName("coca cola");
+ prod.setPrice(5.99);
+ prod.setVolume(12.34d);
+
+ ValueStack stack = ActionContext.getContext().getValueStack();
+ stack.push(prod);
+ ActionContext.getContext().setValueStack(stack);
+
+ val.setMinInclusive(0d);
+ val.setMaxInclusive(30d);
+ val.setFieldName("volume");
+ val.validate(prod);
+ }
+
+ public void testRangeNotADoubleObjectValueInStack() throws Exception {
+ MyTestProduct prod = new MyTestProduct();
+ prod.setName("coca cola");
+
+ ValueStack stack = ActionContext.getContext().getValueStack();
+ stack.push(prod);
+ ActionContext.getContext().setValueStack(stack);
+
+ val.setMinInclusive(0d);
+ val.setMaxInclusive(10d);
+ val.setFieldName("name");
+
+ DelegatingValidatorContext context = new DelegatingValidatorContext(new ValidationAwareSupport(), tpf);
+ val.setValidatorContext(context);
+
+ val.validate(prod);
+
+ assertEquals(0d, val.getMinInclusive());
+ assertEquals(10d, val.getMaxInclusive());
+ }
+
+ public void testEdgeOfMaxRange() throws Exception {
+ MyTestProduct prod = new MyTestProduct();
+ prod.setName("coca cola");
+ prod.setPrice(9.95);
+
+ ValueStack stack = ActionContext.getContext().getValueStack();
+ stack.push(prod);
+ ActionContext.getContext().setValueStack(stack);
+
+ val.setFieldName("price");
+
+ DelegatingValidatorContext context = new DelegatingValidatorContext(new ValidationAwareSupport(), tpf);
+ val.setValidatorContext(context);
+
+ val.setMaxInclusive(9.95d);
+ val.validate(prod); // should pass
+ assertTrue(!context.hasErrors());
+ assertEquals(9.95d, val.getMaxInclusive());
+
+ val.setMaxExclusive(9.95d);
+ val.validate(prod); // should not pass
+ assertTrue(context.hasErrors());
+ assertEquals(9.95d, val.getMaxExclusive());
+ }
+
+ public void testEdgeOfMinRange() throws Exception {
+ MyTestProduct prod = new MyTestProduct();
+ prod.setName("coca cola");
+ prod.setPrice(9.95);
+
+ ValueStack stack = ActionContext.getContext().getValueStack();
+ stack.push(prod);
+ ActionContext.getContext().setValueStack(stack);
+
+ val.setFieldName("price");
+
+ DelegatingValidatorContext context = new DelegatingValidatorContext(new ValidationAwareSupport(), tpf);
+ val.setValidatorContext(context);
+
+ val.setMinInclusive(9.95d);
+ val.validate(prod); // should pass
+ assertTrue(!context.hasErrors());
+
+ val.setMinExclusive(9.95d);
+ val.validate(prod); // should not pass
+ assertTrue(context.hasErrors());
+ }
+
+ public void testNoValue() throws Exception {
+ ValueStack stack = ActionContext.getContext().getValueStack();
+ ActionContext.getContext().setValueStack(stack);
+
+ val.setFieldName("price");
+
+ DelegatingValidatorContext context = new DelegatingValidatorContext(new ValidationAwareSupport(), tpf);
+ val.setValidatorContext(context);
+
+ val.setMinInclusive(9.95d);
+ val.validate(null);
+ assertFalse(context.hasErrors()); // should pass as null value passed in
+ }
+
+ public void testRangeValidationWithExpressionsFail() throws Exception {
+ //Explicitly set an out-of-range double for DoubleRangeValidatorTest
+ Map<String, Object> context = new HashMap<>();
+ HashMap<String, Object> params = new HashMap<>();
+ params.put("percentage", 100.0123d);
+ context.put(ActionContext.PARAMETERS, HttpParameters.create(params).build());
+
+ ActionProxy proxy = actionProxyFactory.createActionProxy("", MockConfigurationProvider.EXPRESSION_VALIDATION_ACTION, null, context);
+ proxy.execute();
+ assertTrue(((ValidationAware) proxy.getAction()).hasFieldErrors());
+
+ Map<String, List<String>> errors = ((ValidationAware) proxy.getAction()).getFieldErrors();
+ List<String> errorMessages = errors.get("percentage");
+ assertNotNull("Expected double range validation error message.", errorMessages);
+ assertEquals(1, errorMessages.size());
+
+ String errorMessage = errorMessages.get(0);
+ assertNotNull("Expecting: percentage must be between 0.1 and 10.1, current value is 100.0123.", errorMessage);
+ assertEquals("percentage must be between 0.1 and 10.1, current value is 100.0123.", errorMessage);
+ }
+
+ public void testExpressionParams() throws Exception {
+ ValueStack stack = ActionContext.getContext().getValueStack();
+ ActionSupport action = new ActionSupport() {
+
+ public Double getMinInclusiveValue() {
+ return 10d;
+ }
+
+ public Double getMaxInclusiveValue() {
+ return 11d;
+ }
+
+ public Double getMinExclusiveValue() {
+ return 13d;
+ }
+
+ public Double getMaxExclusiveValue() {
+ return 14d;
+ }
+
+ public Double getPrice() {
+ return 15d;
+ }
+ };
+
+ stack.push(action);
+
+ val.setMinInclusiveExpression("${minInclusiveValue}");
+ val.setMaxInclusiveExpression("${maxInclusiveValue}");
+ val.setMinExclusiveExpression("${minExclusiveValue}");
+ val.setMaxExclusiveExpression("${maxExclusiveValue}");
+
+ val.setFieldName("price");
+ val.setDefaultMessage("Price is wrong!");
+
+ DelegatingValidatorContext context = new DelegatingValidatorContext(action, tpf);
+ val.setValidatorContext(context);
+
+ val.validate(action);
+ assertTrue(action.getFieldErrors().get("price").size() == 1);
+ }
+
+ public void testArrayOfDoubles() throws Exception {
+ val.setMinInclusive(10d);
+ val.setMaxInclusive(14d);
+
+ val.setFieldName("doubleArray");
+ val.setDefaultMessage("Value ${currentValue} not in scope!");
+
+ MyTestProduct object = new MyTestProduct();
+ object.setDoubleArray(new Double[]{11d, 15d});
+
+ DummyValidatorContext context = new DummyValidatorContext(object, tpf);
+ val.setValidatorContext(context);
+
+ val.validate(object);
+
+ assertTrue(context.hasFieldErrors());
+ assertEquals(1, context.getFieldErrors().size());
+ assertEquals(1, context.getFieldErrors().get("doubleArray").size());
+ assertEquals("Value 15.0 not in scope!", context.getFieldErrors().get("doubleArray").get(0));
+ }
+
+ public void testCollectionOfDoubles() throws Exception {
+ val.setMinInclusive(10d);
+ val.setMaxInclusive(14d);
+
+ val.setFieldName("doubleCollection");
+ val.setDefaultMessage("Value ${currentValue} not in scope!");
+
+ MyTestProduct object = new MyTestProduct();
+ object.setDoubleCollection(Arrays.asList(11d, 15d));
+
+ DummyValidatorContext context = new DummyValidatorContext(object, tpf);
+ val.setValidatorContext(context);
+
+ val.validate(object);
+
+ assertTrue(context.hasFieldErrors());
+ assertEquals(1, context.getFieldErrors().size());
+ assertEquals(1, context.getFieldErrors().get("doubleCollection").size());
+ assertEquals("Value 15.0 not in scope!", context.getFieldErrors().get("doubleCollection").get(0));
+ }
+
+ @Override
+ protected void setUp() throws Exception {
+ super.setUp();
+ XmlConfigurationProvider provider = new XmlConfigurationProvider("xwork-default.xml");
+ container.inject(provider);
+ loadConfigurationProviders(provider, new MockConfigurationProvider());
+ val = new DoubleRangeFieldValidator();
+ val.setValueStack(ActionContext.getContext().getValueStack());
+ ActionContext.getContext().setParameters(HttpParameters.create().build());
+ tpf = container.getInstance(TextProviderFactory.class);
+ }
+
+ @Override
+ protected void tearDown() throws Exception {
+ super.tearDown();
+ val = null;
+ }
+
+ private class MyTestProduct {
+ private double price;
+ private Double volume;
+ private String name;
+
+ private Double[] doubleArray;
+ private Collection<Double> doubleCollection;
+
+ public double getPrice() {
+ return price;
+ }
+
+ public void setPrice(double price) {
+ this.price = price;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ public Double getVolume() {
+ return volume;
+ }
+
+ public void setVolume(Double volume) {
+ this.volume = volume;
+ }
+
+ public Double[] getDoubleArray() {
+ return doubleArray;
+ }
+
+ public void setDoubleArray(Double[] doubleArray) {
+ this.doubleArray = doubleArray;
+ }
+
+ public Collection<Double> getDoubleCollection() {
+ return doubleCollection;
+ }
+
+ public void setDoubleCollection(Collection<Double> doubleCollection) {
+ this.doubleCollection = doubleCollection;
+ }
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/struts/blob/01a56ca1/core/src/test/java/com/opensymphony/xwork2/validator/DoubleRangeValidatorTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/com/opensymphony/xwork2/validator/DoubleRangeValidatorTest.java b/core/src/test/java/com/opensymphony/xwork2/validator/DoubleRangeValidatorTest.java
deleted file mode 100644
index e60d247..0000000
--- a/core/src/test/java/com/opensymphony/xwork2/validator/DoubleRangeValidatorTest.java
+++ /dev/null
@@ -1,279 +0,0 @@
-package com.opensymphony.xwork2.validator;
-
-import com.opensymphony.xwork2.*;
-import com.opensymphony.xwork2.config.providers.MockConfigurationProvider;
-import com.opensymphony.xwork2.config.providers.XmlConfigurationProvider;
-import com.opensymphony.xwork2.interceptor.ValidationAware;
-import com.opensymphony.xwork2.util.ValueStack;
-import com.opensymphony.xwork2.validator.validators.DoubleRangeFieldValidator;
-import org.apache.struts2.dispatcher.HttpParameters;
-
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-/**
- * Unit test for {@link DoubleRangeFieldValidator}.
- *
- * @author <a href="mailto:hermanns@aixcept.de">Rainer Hermanns</a>
- * @author Claus Ibsen
- * @version $Id$
- */
-public class DoubleRangeValidatorTest extends XWorkTestCase {
- private DoubleRangeFieldValidator val;
- private TextProviderFactory tpf;
-
- public void testRangeValidationWithError() throws Exception {
- //Explicitly set an out-of-range double for DoubleRangeValidatorTest
- Map<String, Object> context = new HashMap<>();
- HashMap<String, Object> params = new HashMap<>();
- params.put("percentage", 100.0123d);
- context.put(ActionContext.PARAMETERS, HttpParameters.create(params).build());
-
- ActionProxy proxy = actionProxyFactory.createActionProxy("", MockConfigurationProvider.VALIDATION_ACTION_NAME, null, context);
- proxy.execute();
- assertTrue(((ValidationAware) proxy.getAction()).hasFieldErrors());
-
- Map<String, List<String>> errors = ((ValidationAware) proxy.getAction()).getFieldErrors();
-
- List<String> errorMessages = errors.get("percentage");
- assertNotNull("Expected double range validation error message.", errorMessages);
- assertEquals(1, errorMessages.size());
-
- String errorMessage = errorMessages.get(0);
- assertNotNull("Expecting: percentage must be between 0.1 and 10.1, current value is 100.0123.", errorMessage);
- assertEquals("percentage must be between 0.1 and 10.1, current value is 100.0123.", errorMessage);
- }
-
- public void testRangeValidationNoError() throws Exception {
- Map<String, Object> context = new HashMap<>();
- HashMap<String, Object> params = new HashMap<>();
- params.put("percentage", 1.234567d);
- context.put(ActionContext.PARAMETERS, HttpParameters.create(params).build());
-
- ActionProxy proxy = actionProxyFactory.createActionProxy("", "percentage", null, context);
- proxy.execute();
- assertTrue(((ValidationAware) proxy.getAction()).hasFieldErrors());
-
- Map<String, List<String>> errors = ((ValidationAware) proxy.getAction()).getFieldErrors();
- List<String> errorMessages = errors.get("percentage");
- assertNull("Expected no double range validation error message.", errorMessages);
- }
-
- public void testRangeNoExclusiveAndNoValueInStack() throws Exception {
- val.setFieldName("hello");
- val.validate("world");
- }
-
- public void testRangeSimpleDoubleValueInStack() throws Exception {
- MyTestProduct prod = new MyTestProduct();
- prod.setName("coca cola");
- prod.setPrice(5.99);
-
- ValueStack stack = ActionContext.getContext().getValueStack();
- stack.push(prod);
- ActionContext.getContext().setValueStack(stack);
-
- val.setMinInclusive(0d);
- val.setMaxInclusive(10d);
- val.setFieldName("price");
- val.validate(prod);
- }
-
- public void testRangeRealDoubleValueInStack() throws Exception {
- MyTestProduct prod = new MyTestProduct();
- prod.setName("coca cola");
- prod.setPrice(5.99);
- prod.setVolume(12.34d);
-
- ValueStack stack = ActionContext.getContext().getValueStack();
- stack.push(prod);
- ActionContext.getContext().setValueStack(stack);
-
- val.setMinInclusive(0d);
- val.setMaxInclusive(30d);
- val.setFieldName("volume");
- val.validate(prod);
- }
-
- public void testRangeNotADoubleObjectValueInStack() throws Exception {
- MyTestProduct prod = new MyTestProduct();
- prod.setName("coca cola");
-
- ValueStack stack = ActionContext.getContext().getValueStack();
- stack.push(prod);
- ActionContext.getContext().setValueStack(stack);
-
- val.setMinInclusive(0d);
- val.setMaxInclusive(10d);
- val.setFieldName("name");
-
- DelegatingValidatorContext context = new DelegatingValidatorContext(new ValidationAwareSupport(), tpf);
- val.setValidatorContext(context);
-
- val.validate(prod);
-
- assertEquals(0d, val.getMinInclusive());
- assertEquals(10d, val.getMaxInclusive());
- }
-
- public void testEdgeOfMaxRange() throws Exception {
- MyTestProduct prod = new MyTestProduct();
- prod.setName("coca cola");
- prod.setPrice(9.95);
-
- ValueStack stack = ActionContext.getContext().getValueStack();
- stack.push(prod);
- ActionContext.getContext().setValueStack(stack);
-
- val.setFieldName("price");
-
- DelegatingValidatorContext context = new DelegatingValidatorContext(new ValidationAwareSupport(), tpf);
- val.setValidatorContext(context);
-
- val.setMaxInclusive(9.95d);
- val.validate(prod); // should pass
- assertTrue(!context.hasErrors());
- assertEquals(9.95d, val.getMaxInclusive());
-
- val.setMaxExclusive(9.95d);
- val.validate(prod); // should not pass
- assertTrue(context.hasErrors());
- assertEquals(9.95d, val.getMaxExclusive());
- }
-
- public void testEdgeOfMinRange() throws Exception {
- MyTestProduct prod = new MyTestProduct();
- prod.setName("coca cola");
- prod.setPrice(9.95);
-
- ValueStack stack = ActionContext.getContext().getValueStack();
- stack.push(prod);
- ActionContext.getContext().setValueStack(stack);
-
- val.setFieldName("price");
-
- DelegatingValidatorContext context = new DelegatingValidatorContext(new ValidationAwareSupport(), tpf);
- val.setValidatorContext(context);
-
- val.setMinInclusive(9.95d);
- val.validate(prod); // should pass
- assertTrue(!context.hasErrors());
-
- val.setMinExclusive(9.95d);
- val.validate(prod); // should not pass
- assertTrue(context.hasErrors());
- }
-
- public void testNoValue() throws Exception {
- ValueStack stack = ActionContext.getContext().getValueStack();
- ActionContext.getContext().setValueStack(stack);
-
- val.setFieldName("price");
-
- DelegatingValidatorContext context = new DelegatingValidatorContext(new ValidationAwareSupport(), tpf);
- val.setValidatorContext(context);
-
- val.setMinInclusive(9.95d);
- val.validate(null);
- assertTrue(!context.hasErrors()); // should pass as null value passed in
- }
-
- public void testRangeValidationWithExpressionsFail() throws Exception {
- //Explicitly set an out-of-range double for DoubleRangeValidatorTest
- Map<String, Object> context = new HashMap<>();
- HashMap<String, Object> params = new HashMap<>();
- params.put("percentage", 100.0123d);
- context.put(ActionContext.PARAMETERS, HttpParameters.create(params).build());
-
- ActionProxy proxy = actionProxyFactory.createActionProxy("", MockConfigurationProvider.EXPRESSION_VALIDATION_ACTION, null, context);
- proxy.execute();
- assertTrue(((ValidationAware) proxy.getAction()).hasFieldErrors());
-
- Map<String, List<String>> errors = ((ValidationAware) proxy.getAction()).getFieldErrors();
- List<String> errorMessages = errors.get("percentage");
- assertNotNull("Expected double range validation error message.", errorMessages);
- assertEquals(1, errorMessages.size());
-
- String errorMessage = errorMessages.get(0);
- assertNotNull("Expecting: percentage must be between 0.1 and 10.1, current value is 100.0123.", errorMessage);
- assertEquals("percentage must be between 0.1 and 10.1, current value is 100.0123.", errorMessage);
- }
-
- public void testExpressionParams() throws Exception {
- ValueStack stack = ActionContext.getContext().getValueStack();
- ActionSupport action = new ActionSupport() {
-
- public Double getMinInclusiveValue() {return 10d;}
- public Double getMaxInclusiveValue() {return 11d;}
- public Double getMinExclusiveValue() {return 13d;}
- public Double getMaxExclusiveValue() {return 14d;}
- public Double getPrice() {return 15d;}
- };
-
- stack.push(action);
-
- val.setMinInclusiveExpression("${minInclusiveValue}");
- val.setMaxInclusiveExpression("${maxInclusiveValue}");
- val.setMinExclusiveExpression("${minExclusiveValue}");
- val.setMaxExclusiveExpression("${maxExclusiveValue}");
-
- val.setFieldName("price");
- val.setDefaultMessage("Price is wrong!");
-
- DelegatingValidatorContext context = new DelegatingValidatorContext(action, tpf);
- val.setValidatorContext(context);
-
- val.validate(action);
- assertTrue(action.getFieldErrors().get("price").size() == 1);
- }
-
- @Override
- protected void setUp() throws Exception {
- super.setUp();
- XmlConfigurationProvider provider = new XmlConfigurationProvider("xwork-default.xml");
- container.inject(provider);
- loadConfigurationProviders(provider, new MockConfigurationProvider());
- val = new DoubleRangeFieldValidator();
- val.setValueStack(ActionContext.getContext().getValueStack());
- ActionContext.getContext().setParameters(HttpParameters.create().build());
- tpf = container.getInstance(TextProviderFactory.class);
- }
-
- @Override
- protected void tearDown() throws Exception {
- super.tearDown();
- val = null;
- }
-
- private class MyTestProduct {
- private double price;
- private Double volume;
- private String name;
-
- public double getPrice() {
- return price;
- }
-
- public void setPrice(double price) {
- this.price = price;
- }
-
- public String getName() {
- return name;
- }
-
- public void setName(String name) {
- this.name = name;
- }
-
- public Double getVolume() {
- return volume;
- }
-
- public void setVolume(Double volume) {
- this.volume = volume;
- }
- }
-
-}