001 /** 002 * Copyright 2005-2013 The Kuali Foundation 003 * 004 * Licensed under the Educational Community License, Version 2.0 (the "License"); 005 * you may not use this file except in compliance with the License. 006 * You may obtain a copy of the License at 007 * 008 * http://www.opensource.org/licenses/ecl2.php 009 * 010 * Unless required by applicable law or agreed to in writing, software 011 * distributed under the License is distributed on an "AS IS" BASIS, 012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 013 * See the License for the specific language governing permissions and 014 * limitations under the License. 015 */ 016 package org.kuali.rice.krad.datadictionary.validation.constraint; 017 018 import java.io.IOException; 019 import java.io.InputStream; 020 import java.util.ArrayList; 021 import java.util.List; 022 import java.util.Properties; 023 024 import org.junit.Assert; 025 import org.junit.Before; 026 import org.junit.Ignore; 027 import org.junit.Test; 028 import org.kuali.rice.krad.datadictionary.AttributeDefinition; 029 import org.kuali.rice.krad.datadictionary.BusinessObjectEntry; 030 import org.kuali.rice.krad.datadictionary.validation.Account; 031 import org.kuali.rice.krad.datadictionary.validation.AttributeValueReader; 032 import org.kuali.rice.krad.datadictionary.validation.DictionaryObjectAttributeValueReader; 033 import org.kuali.rice.krad.datadictionary.validation.ErrorLevel; 034 import org.kuali.rice.krad.datadictionary.validation.constraint.ValidCharactersConstraint; 035 import org.kuali.rice.krad.datadictionary.validation.processor.ValidCharactersConstraintProcessor; 036 import org.kuali.rice.krad.datadictionary.validation.result.ConstraintValidationResult; 037 import org.kuali.rice.krad.datadictionary.validation.result.DictionaryValidationResult; 038 039 040 /** 041 * Things this test should check: 042 * 043 * 1. empty value check. (failure) {@link #testValueEmpty()} 044 * 2. value with valid positive number. (success) {@link #testValueValidPositiveNumber()} 045 * 3. value with invalid negative number as allowNegative set to false. (failure) {@link #testValueInvalidNegativeNumber()} 046 * 4. value with valid negative number as allowNegative set to true. (success) {@link #testValueValidNegativeNumber()} 047 * 5. value with invalid negative number as allowNegative set to true.. (failure) {@link #testValueInvalidNegativeNumber1()} 048 * 6. value with invalid positive number. (failure) {@link #testValueInvalidPositiveNumber()} 049 * 7. value with valid negative number as allowNegative set to true. (success) {@link #testValueValidNegativeNumber1)} 050 * 051 * @author Kuali Rice Team (rice.collab@kuali.org) 052 */ 053 public class FloatingPointPatternConstraintTest { 054 055 private final String PATTERN_CONSTRAINT = "validationPatternRegex.floatingPoint"; 056 057 private AttributeDefinition totalBalanceDefinition; 058 private AttributeDefinition debitBalanceDefinition; 059 060 private BusinessObjectEntry addressEntry; 061 private DictionaryValidationResult dictionaryValidationResult; 062 063 private ValidCharactersConstraintProcessor processor; 064 065 private Account iciciAccount = new Account("11111111","ICICI","5000.00","15000","-10000"); 066 private Account citibankAccount = new Account("22222222","Citi Bank","15000.70","14999.70","1."); 067 private Account wellsFargoAccount = new Account("33333333","Wells Fargo","",".25","-.25"); 068 private Account morganAccount = new Account("44444444","J P Morgan","-1000.00","1000.00","(2000.00)"); 069 070 private FloatingPointPatternConstraint totalBalanceFloatingPointPatternConstraint; 071 private FloatingPointPatternConstraint debitBalanceFloatingPointPatternConstraint; 072 073 @Before 074 public void setUp() throws Exception { 075 076 String regex = getProperty(PATTERN_CONSTRAINT); 077 078 processor = new ValidCharactersConstraintProcessor(); 079 080 dictionaryValidationResult = new DictionaryValidationResult(); 081 dictionaryValidationResult.setErrorLevel(ErrorLevel.NOCONSTRAINT); 082 083 addressEntry = new BusinessObjectEntry(); 084 085 List<AttributeDefinition> attributes = new ArrayList<AttributeDefinition>(); 086 087 totalBalanceFloatingPointPatternConstraint = new FloatingPointPatternConstraint(); 088 totalBalanceFloatingPointPatternConstraint.setMessageKey("validate.dummykey"); 089 totalBalanceFloatingPointPatternConstraint.setValidationMessageParams( new ArrayList<String>()); 090 totalBalanceFloatingPointPatternConstraint.setValue(regex); 091 092 totalBalanceDefinition = new AttributeDefinition(); 093 totalBalanceDefinition.setName("totalBalance"); 094 totalBalanceDefinition.setValidCharactersConstraint(totalBalanceFloatingPointPatternConstraint); 095 attributes.add(totalBalanceDefinition); 096 097 debitBalanceFloatingPointPatternConstraint = new FloatingPointPatternConstraint(); 098 debitBalanceFloatingPointPatternConstraint.setMessageKey("validate.dummykey"); 099 debitBalanceFloatingPointPatternConstraint.setValidationMessageParams( new ArrayList<String>()); 100 debitBalanceFloatingPointPatternConstraint.setValue("-?"+regex); 101 debitBalanceFloatingPointPatternConstraint.setAllowNegative(true); 102 103 debitBalanceDefinition = new AttributeDefinition(); 104 debitBalanceDefinition.setName("debitBalance"); 105 debitBalanceDefinition.setValidCharactersConstraint(debitBalanceFloatingPointPatternConstraint); 106 attributes.add(debitBalanceDefinition); 107 108 109 addressEntry.setAttributes(attributes); 110 } 111 112 @Test 113 public void testValueEmpty() { 114 ConstraintValidationResult result = process(wellsFargoAccount, "totalBalance", totalBalanceFloatingPointPatternConstraint); 115 Assert.assertEquals(0, dictionaryValidationResult.getNumberOfWarnings()); 116 Assert.assertEquals(0, dictionaryValidationResult.getNumberOfErrors()); 117 Assert.assertEquals(ErrorLevel.INAPPLICABLE, result.getStatus()); 118 Assert.assertEquals(new ValidCharactersConstraintProcessor().getName(), result.getConstraintName()); 119 } 120 121 @Test 122 public void testValueValidPositiveNumber() { 123 ConstraintValidationResult result = process(citibankAccount, "totalBalance", totalBalanceFloatingPointPatternConstraint); 124 Assert.assertEquals(0, dictionaryValidationResult.getNumberOfWarnings()); 125 Assert.assertEquals(0, dictionaryValidationResult.getNumberOfErrors()); 126 Assert.assertEquals(ErrorLevel.OK, result.getStatus()); 127 Assert.assertEquals(new ValidCharactersConstraintProcessor().getName(), result.getConstraintName()); 128 } 129 130 @Test 131 public void testValueInvalidNegativeNumber() { 132 ConstraintValidationResult result = process(morganAccount, "totalBalance", totalBalanceFloatingPointPatternConstraint); 133 Assert.assertEquals(0, dictionaryValidationResult.getNumberOfWarnings()); 134 Assert.assertEquals(1, dictionaryValidationResult.getNumberOfErrors()); 135 Assert.assertEquals(ErrorLevel.ERROR, result.getStatus()); 136 Assert.assertEquals(new ValidCharactersConstraintProcessor().getName(), result.getConstraintName()); 137 } 138 139 @Test 140 public void testValueValidNegativeNumber() { 141 ConstraintValidationResult result = process(iciciAccount, "debitBalance", debitBalanceFloatingPointPatternConstraint); 142 Assert.assertEquals(0, dictionaryValidationResult.getNumberOfWarnings()); 143 Assert.assertEquals(0, dictionaryValidationResult.getNumberOfErrors()); 144 Assert.assertEquals(ErrorLevel.OK, result.getStatus()); 145 Assert.assertEquals(new ValidCharactersConstraintProcessor().getName(), result.getConstraintName()); 146 } 147 148 @Test 149 public void testValueInvalidNegativeNumber1() { 150 ConstraintValidationResult result = process(morganAccount, "debitBalance", debitBalanceFloatingPointPatternConstraint); 151 Assert.assertEquals(0, dictionaryValidationResult.getNumberOfWarnings()); 152 Assert.assertEquals(1, dictionaryValidationResult.getNumberOfErrors()); 153 Assert.assertEquals(ErrorLevel.ERROR, result.getStatus()); 154 Assert.assertEquals(new ValidCharactersConstraintProcessor().getName(), result.getConstraintName()); 155 } 156 157 @Test 158 public void testValueInvalidPositiveNumber() { 159 ConstraintValidationResult result = process(citibankAccount, "debitBalance", debitBalanceFloatingPointPatternConstraint); 160 Assert.assertEquals(0, dictionaryValidationResult.getNumberOfWarnings()); 161 Assert.assertEquals(1, dictionaryValidationResult.getNumberOfErrors()); 162 Assert.assertEquals(ErrorLevel.ERROR, result.getStatus()); 163 Assert.assertEquals(new ValidCharactersConstraintProcessor().getName(), result.getConstraintName()); 164 } 165 166 @Test 167 public void testValueValidNegativeNumber1() { 168 ConstraintValidationResult result = process(wellsFargoAccount, "debitBalance", debitBalanceFloatingPointPatternConstraint); 169 Assert.assertEquals(0, dictionaryValidationResult.getNumberOfWarnings()); 170 Assert.assertEquals(0, dictionaryValidationResult.getNumberOfErrors()); 171 Assert.assertEquals(ErrorLevel.OK, result.getStatus()); 172 Assert.assertEquals(new ValidCharactersConstraintProcessor().getName(), result.getConstraintName()); 173 } 174 175 private ConstraintValidationResult process(Object object, String attributeName, ValidCharactersConstraint constraint) { 176 AttributeValueReader attributeValueReader = new DictionaryObjectAttributeValueReader(object, "org.kuali.rice.kns.datadictionary.validation.MockAddress", addressEntry); 177 attributeValueReader.setAttributeName(attributeName); 178 179 Object value = attributeValueReader.getValue(); 180 return processor.process(dictionaryValidationResult, value, constraint, attributeValueReader).getFirstConstraintValidationResult(); 181 } 182 183 private String getProperty(String key) { 184 String value = null; 185 String filePath = "org/kuali/rice/krad/ApplicationResources.properties"; 186 Properties properties = new Properties(); 187 try { 188 InputStream in = Thread.currentThread().getContextClassLoader().getResourceAsStream(filePath); 189 properties.load(in); 190 value = properties.getProperty(key); 191 } catch (IOException e) { 192 } 193 return value; 194 } 195 }