001: package org.strecks.validator.internal;
002:
003: import static org.easymock.EasyMock.expect;
004: import static org.easymock.classextension.EasyMock.createStrictMock;
005: import static org.easymock.classextension.EasyMock.replay;
006: import static org.easymock.classextension.EasyMock.reset;
007: import static org.easymock.classextension.EasyMock.verify;
008:
009: import java.util.ArrayList;
010: import java.util.Collections;
011: import java.util.List;
012:
013: import org.strecks.exceptions.ApplicationConfigurationException;
014: import org.strecks.validator.IntegerValidator;
015: import org.strecks.validator.message.DefaultMessageParameterProvider;
016: import org.testng.Assert;
017: import org.testng.annotations.Test;
018:
019: /**
020: * @author Phil Zoio
021: */
022: public class TestConvertedTypeValidationChecker {
023:
024: @Test
025: public void testIsInterface() {
026:
027: List<ValidatorWrapper> list = new ArrayList<ValidatorWrapper>();
028: ValidatorWrapper v1 = getWrapper(List.class);
029: list.add(v1);
030:
031: ConvertedTypeValidationChecker checker = new ConvertedTypeValidationChecker(
032: this .getClass(), newOrderedProperty(), list);
033:
034: try {
035: checker.checkConvertedValueTypes();
036: Assert.fail();
037: } catch (ApplicationConfigurationException e) {
038: Assert
039: .assertEquals(
040: e.getMessage(),
041: "Class org.strecks.validator.internal.TestConvertedTypeValidationChecker, "
042: + "property prop uses validators for which the most concrete parameterized type java.util.List is an interface. "
043: + "It must be an instantiable concrete class");
044: }
045:
046: }
047:
048: @Test
049: public void testIsAbstract() {
050:
051: List<ValidatorWrapper> list = new ArrayList<ValidatorWrapper>();
052: ValidatorWrapper v1 = getWrapper(Number.class);
053: list.add(v1);
054:
055: ConvertedTypeValidationChecker checker = new ConvertedTypeValidationChecker(
056: this .getClass(), newOrderedProperty(), list);
057:
058: try {
059: checker.checkConvertedValueTypes();
060: Assert.fail();
061: } catch (ApplicationConfigurationException e) {
062: Assert
063: .assertEquals(
064: e.getMessage(),
065: "Class org.strecks.validator.internal.TestConvertedTypeValidationChecker, "
066: + "property prop uses validators for which the most concrete parameterized type java.lang.Number is an abstract class. "
067: + "It must be an instantiable concrete class");
068: }
069:
070: }
071:
072: @Test
073: public void testSortWrappers() {
074:
075: List<ValidatorWrapper> list = new ArrayList<ValidatorWrapper>();
076:
077: ValidatorWrapper v1 = getWrapper(Integer.class);
078: ValidatorWrapper v2 = getWrapper(Number.class);
079: ValidatorWrapper v3 = getWrapper(Object.class);
080:
081: list.add(v1);
082: list.add(v2);
083: list.add(v3);
084:
085: ConvertedTypeValidationChecker checker = new ConvertedTypeValidationChecker(
086: this .getClass(), newOrderedProperty(), list);
087: assert checker.checkUsesConvertedValue();
088:
089: checker.sortValidators();
090:
091: assert v1 == checker.getSortableValidators().iterator().next()
092: .getWrapper();
093:
094: // now check that sort applies in reverse
095: list.clear();
096:
097: list.add(v2);
098: list.add(v3);
099: list.add(v1);
100:
101: checker = new ConvertedTypeValidationChecker(this .getClass(),
102: newOrderedProperty(), list);
103: checker.sortValidators();
104:
105: assert v1 == checker.getSortableValidators().iterator().next()
106: .getWrapper();
107:
108: // check all are assignable
109: checker.checkAllAreAssignable();
110:
111: checker.setConverterType();
112:
113: Assert.assertEquals(Integer.class, checker.getConverterType());
114:
115: }
116:
117: @Test
118: public void testNotTypeCompatible() {
119:
120: List<ValidatorWrapper> list = new ArrayList<ValidatorWrapper>();
121:
122: ValidatorWrapper v1 = getWrapper(Integer.class);
123: ValidatorWrapper v2 = getWrapper(String.class);
124: ValidatorWrapper v3 = getWrapper(Object.class);
125:
126: list.add(v1);
127: list.add(v2);
128: list.add(v3);
129:
130: ConvertedTypeValidationChecker checker = new ConvertedTypeValidationChecker(
131: this .getClass(), newOrderedProperty(), list);
132: assert checker.checkUsesConvertedValue();
133:
134: checker.sortValidators();
135:
136: assert v1 == checker.getSortableValidators().iterator().next()
137: .getWrapper();
138:
139: // now check that sort applies in reverse
140: list.clear();
141:
142: list.add(v2);
143: list.add(v3);
144: list.add(v1);
145:
146: checker = new ConvertedTypeValidationChecker(this .getClass(),
147: newOrderedProperty(), list);
148: checker.sortValidators();
149:
150: assert v2 == checker.getSortableValidators().iterator().next()
151: .getWrapper();
152:
153: // check all are assignable
154: try {
155: checker.checkAllAreAssignable();
156: Assert.fail();
157: } catch (ApplicationConfigurationException e) {
158: Assert
159: .assertEquals(
160: e.getMessage(),
161: "Class org.strecks.validator.internal.TestConvertedTypeValidationChecker, "
162: + "property prop uses validators "
163: + "with parameterized types java.lang.String and java.lang.Integer which are not type compatible");
164: }
165:
166: }
167:
168: private ValidatorWrapper getWrapper(Class<?> type) {
169: DefaultMessageParameterProvider provider = new DefaultMessageParameterProvider();
170: ValidatorWrapper wrapper = new ValidatorWrapper("key1", 20,
171: Collections.emptyList(), new IntegerValidator(), this
172: .getClass().getMethods()[0], provider, true,
173: type);
174: return wrapper;
175: }
176:
177: @Test
178: public void testUsesConvertedValue() {
179:
180: ValidatorWrapper wrapper1 = createStrictMock(ValidatorWrapper.class);
181: ValidatorWrapper wrapper2 = createStrictMock(ValidatorWrapper.class);
182: ValidatorWrapper wrapper3 = createStrictMock(ValidatorWrapper.class);
183: List<ValidatorWrapper> list = new ArrayList<ValidatorWrapper>();
184: list.add(wrapper1);
185: list.add(wrapper2);
186: list.add(wrapper3);
187:
188: expect(wrapper1.getUsesConvertedValue()).andReturn(false);
189: expect(wrapper2.getUsesConvertedValue()).andReturn(true);
190:
191: for (ValidatorWrapper wrapper : list) {
192: replay(wrapper);
193: }
194:
195: ConvertedTypeValidationChecker checker = new ConvertedTypeValidationChecker(
196: this .getClass(), newOrderedProperty(), list);
197: assert checker.checkUsesConvertedValue();
198:
199: for (ValidatorWrapper wrapper : list) {
200: verify(wrapper);
201: }
202:
203: for (ValidatorWrapper wrapper : list) {
204: reset(wrapper);
205: }
206:
207: expect(wrapper1.getUsesConvertedValue()).andReturn(false);
208: expect(wrapper2.getUsesConvertedValue()).andReturn(false);
209: expect(wrapper3.getUsesConvertedValue()).andReturn(false);
210:
211: for (ValidatorWrapper wrapper : list) {
212: replay(wrapper);
213: }
214:
215: assert !checker.checkUsesConvertedValue();
216:
217: for (ValidatorWrapper wrapper : list) {
218: verify(wrapper);
219: }
220:
221: for (ValidatorWrapper wrapper : list) {
222: reset(wrapper);
223: }
224: }
225:
226: private OrderedProperty newOrderedProperty() {
227: return new OrderedProperty("prop", 1);
228: }
229: }
|