├── .gitignore ├── README.md ├── pom.xml └── src ├── main └── java │ ├── com │ ├── calculator │ │ └── enumuse │ │ │ ├── CalculatorContext.java │ │ │ ├── CalculatorInput.java │ │ │ ├── CalculatorOperationStrategy.java │ │ │ ├── ExtendedCalculatorOperationStrategy.java │ │ │ ├── InvalidOperationException.java │ │ │ └── OperationStrategy.java │ └── validation │ │ └── enumuse │ │ ├── ExtendedValidationStrategy.java │ │ ├── UserInput.java │ │ ├── UserValidationContext.java │ │ ├── UserValidationStrategy.java │ │ └── ValidationStrategy.java │ └── constants │ ├── OperationType.java │ └── ValidationType.java └── test └── java └── com ├── calculator └── enumuse │ └── CalculatorTest.java └── validator └── enumuse └── ValidatorTest.java /.gitignore: -------------------------------------------------------------------------------- 1 | *.class 2 | /target 3 | /local 4 | 5 | # Eclipse, Netbeans and IntelliJ files 6 | /.* 7 | !.gitignore 8 | /nbproject 9 | /*.ipr 10 | /*.iws 11 | /*.iml 12 | 13 | # Mobile Tools for Java (J2ME) 14 | .mtj.tmp/ 15 | 16 | # Package Files # 17 | *.jar 18 | *.war 19 | *.ear 20 | 21 | # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml 22 | hs_err_pid* 23 | 24 | # Repository wide ignore mac DS_Store files 25 | .DS_Store 26 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Java Adhoc Examples 2 | This repo contains examples for various scenarios. The below list will explain the scenarios and the corresponding packages. 3 | 4 | # Scenarios 5 | 1. Simplifying the validations using the Strategy(Enum) pattern 6 | - UserInputValidation example: package - src/main/java/com.validator.enumuse 7 | - Calculator example: package - src/main/java/com.calculator.enumuse 8 | - Test packages: src/test/java/com.validator.enumuse and src/test/java/com.calculator.enumuse 9 | -------------------------------------------------------------------------------- /pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 4.0.0 6 | 7 | java.adhoc.examples 8 | adhoc-examples 9 | 1.0-SNAPSHOT 10 | 11 | 12 | 13 | junit 14 | junit 15 | 4.11 16 | 17 | 18 | 19 | 20 | src 21 | 22 | 23 | maven-compiler-plugin 24 | 3.1 25 | 26 | 1.6 27 | 1.6 28 | 29 | 30 | 31 | 32 | 33 | -------------------------------------------------------------------------------- /src/main/java/com/calculator/enumuse/CalculatorContext.java: -------------------------------------------------------------------------------- 1 | package com.calculator.enumuse; 2 | 3 | import java.util.Iterator; 4 | import java.util.Set; 5 | 6 | public class CalculatorContext { 7 | private Set strategies; 8 | 9 | public CalculatorContext(Set strategies) { 10 | this.strategies = strategies; 11 | } 12 | 13 | public int execute(CalculatorInput calcInput) { 14 | for (Iterator iterator = strategies.iterator(); iterator.hasNext();) { 15 | OperationStrategy calcValidation = iterator.next(); 16 | if (calcValidation.validate(calcInput)) { 17 | return calcValidation.getResult(calcInput); 18 | } 19 | } 20 | throw new InvalidOperationException("Unsupported calculator operation: " + calcInput.getOperator()); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/main/java/com/calculator/enumuse/CalculatorInput.java: -------------------------------------------------------------------------------- 1 | package com.calculator.enumuse; 2 | 3 | public class CalculatorInput { 4 | private int operand1, operand2; 5 | private String operator; 6 | 7 | public CalculatorInput(String operator, int operand1, int operand2) { 8 | this.operand1 = operand1; 9 | this.operand2 = operand2; 10 | this.operator = operator; 11 | } 12 | 13 | public int getOperand1() { 14 | return operand1; 15 | } 16 | 17 | public void setOperand1(int operand1) { 18 | this.operand1 = operand1; 19 | } 20 | 21 | public int getOperand2() { 22 | return operand2; 23 | } 24 | 25 | public void setOperand2(int operand2) { 26 | this.operand2 = operand2; 27 | } 28 | 29 | public String getOperator() { 30 | return operator; 31 | } 32 | 33 | public void setOperator(String operator) { 34 | this.operator = operator; 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /src/main/java/com/calculator/enumuse/CalculatorOperationStrategy.java: -------------------------------------------------------------------------------- 1 | 2 | package com.calculator.enumuse; 3 | 4 | import constants.OperationType; 5 | 6 | import java.util.Iterator; 7 | import java.util.Set; 8 | 9 | public enum CalculatorOperationStrategy implements OperationStrategy { 10 | 11 | ADD(OperationType.ADDITION) { 12 | public boolean validate(T input) { 13 | if(input.getOperator().equals(OperationType.ADDITION.getValue())) { 14 | return true; 15 | } 16 | return false; 17 | } 18 | 19 | public int getResult(T input) { 20 | return input.getOperand1() + input.getOperand2(); 21 | } 22 | }, 23 | SUBTRACTION(OperationType.SUBTRACTION) { 24 | public boolean validate(T input) { 25 | if(input.getOperator().equals(OperationType.SUBTRACTION.getValue())) { 26 | return true; 27 | } 28 | return false; 29 | } 30 | public int getResult(T input) { 31 | return input.getOperand1() - input.getOperand2(); 32 | } 33 | }, 34 | MULTIPLICATION(OperationType.MULTIPLICATION) { 35 | public boolean validate(T input) { 36 | if(input.getOperator().equals(OperationType.MULTIPLICATION.getValue())) { 37 | return true; 38 | } 39 | return false; 40 | } 41 | public int getResult(T input) { 42 | return input.getOperand1() * input.getOperand2(); 43 | } 44 | // }, 45 | // DIVISION(OperationType.DIVISION) { 46 | // public boolean validate(T input) { 47 | // if(input.getOperator().equals(OperationType.DIVISION.getValue())) { 48 | // return true; 49 | // } 50 | // return false; 51 | // } 52 | // public int getResult(T input) { 53 | // return input.getOperand1() / input.getOperand2(); 54 | // } 55 | }; 56 | 57 | 58 | private OperationType operation; 59 | 60 | private CalculatorOperationStrategy(OperationType operation) { 61 | this.operation = operation; 62 | } 63 | 64 | } 65 | -------------------------------------------------------------------------------- /src/main/java/com/calculator/enumuse/ExtendedCalculatorOperationStrategy.java: -------------------------------------------------------------------------------- 1 | package com.calculator.enumuse; 2 | 3 | 4 | import constants.OperationType; 5 | 6 | public enum ExtendedCalculatorOperationStrategy implements OperationStrategy { 7 | 8 | DIVISION(OperationType.DIVISION) { 9 | public boolean validate(T input) { 10 | if(input.getOperator().equals(OperationType.DIVISION.getValue())) { 11 | return true; 12 | } 13 | return false; 14 | } 15 | 16 | public int getResult(T input) { 17 | return input.getOperand1() / input.getOperand2(); 18 | } 19 | }; 20 | 21 | private OperationType operation; 22 | private ExtendedCalculatorOperationStrategy(OperationType operation) { 23 | this.operation = operation; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/main/java/com/calculator/enumuse/InvalidOperationException.java: -------------------------------------------------------------------------------- 1 | package com.calculator.enumuse; 2 | 3 | public class InvalidOperationException extends RuntimeException { 4 | public InvalidOperationException(String msg) { 5 | super(msg); 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /src/main/java/com/calculator/enumuse/OperationStrategy.java: -------------------------------------------------------------------------------- 1 | package com.calculator.enumuse; 2 | 3 | public interface OperationStrategy { 4 | boolean validate(T input); 5 | int getResult(T input); 6 | 7 | } 8 | -------------------------------------------------------------------------------- /src/main/java/com/validation/enumuse/ExtendedValidationStrategy.java: -------------------------------------------------------------------------------- 1 | package com.validation.enumuse; 2 | 3 | import constants.ValidationType; 4 | 5 | public enum ExtendedValidationStrategy implements ValidationStrategy { 6 | 7 | BANK_ACCOUNT_TYPE (ValidationType.BANK_ACCOUNT_TYPE) { 8 | public boolean validate(T input) { 9 | if(input.isUserValid() && input.isBankAdded() && input.getBankAccountType().isEmpty() ) { 10 | return true; 11 | } 12 | return false; 13 | } 14 | }; 15 | 16 | private ValidationType validationType; 17 | 18 | private ExtendedValidationStrategy(ValidationType validationType) { 19 | this.validationType = validationType; 20 | } 21 | 22 | public ValidationType getValidationType() { 23 | return validationType; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/main/java/com/validation/enumuse/UserInput.java: -------------------------------------------------------------------------------- 1 | package com.validation.enumuse; 2 | 3 | public class UserInput { 4 | private String dateOfBirth; 5 | private String city; 6 | private String zip; 7 | private String country; 8 | private String ssn; 9 | private String creditCardNumber; 10 | private String bankRoutingNumber; 11 | private String bankAccountNumber; 12 | private String bankName; 13 | private String bankCity; 14 | private String bankZip; 15 | private String bankCountry; 16 | private boolean isUserValid; 17 | private boolean isFullFunding; 18 | private boolean isBankAdded; 19 | private boolean isCreditCardAdded; 20 | private String bankAccountType; 21 | 22 | public String getDateOfBirth() { 23 | return dateOfBirth; 24 | } 25 | 26 | public void setDateOfBirth(String dateOfBirth) { 27 | this.dateOfBirth = dateOfBirth; 28 | } 29 | 30 | public String getCity() { 31 | return city; 32 | } 33 | 34 | public void setCity(String city) { 35 | this.city = city; 36 | } 37 | 38 | public String getZip() { 39 | return zip; 40 | } 41 | 42 | public void setZip(String zip) { 43 | this.zip = zip; 44 | } 45 | 46 | public String getCountry() { 47 | return country; 48 | } 49 | 50 | public void setCountry(String country) { 51 | this.country = country; 52 | } 53 | 54 | public String getSsn() { 55 | return ssn; 56 | } 57 | 58 | public void setSsn(String ssn) { 59 | this.ssn = ssn; 60 | } 61 | 62 | public String getCreditCardNumber() { 63 | return creditCardNumber; 64 | } 65 | 66 | public void setCreditCardNumber(String creditCardNumber) { 67 | this.creditCardNumber = creditCardNumber; 68 | } 69 | 70 | public String getBankRoutingNumber() { 71 | return bankRoutingNumber; 72 | } 73 | 74 | public void setBankRoutingNumber(String bankRoutingNumber) { 75 | this.bankRoutingNumber = bankRoutingNumber; 76 | } 77 | 78 | public String getBankAccountNumber() { 79 | return bankAccountNumber; 80 | } 81 | 82 | public void setBankAccountNumber(String bankAccountNumber) { 83 | this.bankAccountNumber = bankAccountNumber; 84 | } 85 | 86 | public String getBankName() { 87 | return bankName; 88 | } 89 | 90 | public void setBankName(String bankName) { 91 | this.bankName = bankName; 92 | } 93 | 94 | public String getBankCity() { 95 | return bankCity; 96 | } 97 | 98 | public void setBankCity(String bankCity) { 99 | this.bankCity = bankCity; 100 | } 101 | 102 | public String getBankZip() { 103 | return bankZip; 104 | } 105 | 106 | public void setBankZip(String bankZip) { 107 | this.bankZip = bankZip; 108 | } 109 | 110 | public String getBankCountry() { 111 | return bankCountry; 112 | } 113 | 114 | public void setBankCountry(String bankCountry) { 115 | this.bankCountry = bankCountry; 116 | } 117 | 118 | public boolean isUserValid() { 119 | return isUserValid; 120 | } 121 | 122 | public void setUserValid(boolean isUserValid) { 123 | this.isUserValid = isUserValid; 124 | } 125 | 126 | public boolean isFullFunding() { 127 | return isFullFunding; 128 | } 129 | 130 | public void setFullFunding(boolean isFullFunding) { 131 | this.isFullFunding = isFullFunding; 132 | } 133 | 134 | public boolean isBankAdded() { 135 | return isBankAdded; 136 | } 137 | 138 | public void setBankAdded(boolean isBankAdded) { 139 | this.isBankAdded = isBankAdded; 140 | } 141 | 142 | public boolean isCreditCardAdded() { 143 | return isCreditCardAdded; 144 | } 145 | 146 | public void setCreditCardAdded(boolean isCreditCardAdded) { 147 | this.isCreditCardAdded = isCreditCardAdded; 148 | } 149 | 150 | public String getBankAccountType() { 151 | return bankAccountType; 152 | } 153 | 154 | public void setBankAccountType(String bankAccountType) { 155 | this.bankAccountType = bankAccountType; 156 | } 157 | } 158 | -------------------------------------------------------------------------------- /src/main/java/com/validation/enumuse/UserValidationContext.java: -------------------------------------------------------------------------------- 1 | package com.validation.enumuse; 2 | 3 | import com.calculator.enumuse.InvalidOperationException; 4 | import constants.ValidationType; 5 | 6 | import java.util.ArrayList; 7 | import java.util.Iterator; 8 | import java.util.List; 9 | import java.util.Set; 10 | 11 | public class UserValidationContext { 12 | private Set userValidationStrategies; 13 | 14 | public UserValidationContext(Set userValidationStrategies) { 15 | this.userValidationStrategies = userValidationStrategies; 16 | } 17 | 18 | /* 19 | * This method performs validation for fields one by one and return the invalid one if found. 20 | * Otherwise, it will continue validating remaining fields. If all the fields are valid then will return null. 21 | */ 22 | public ValidationType execute(UserInput userInput) { 23 | ValidationStrategy userValidation = UserValidationStrategy.UNSUPPORTED; 24 | for (Iterator iterator = userValidationStrategies.iterator(); iterator.hasNext();) { 25 | userValidation = iterator.next(); 26 | if (userValidation.validate(userInput)) { 27 | return userValidation.getValidationType(); 28 | } 29 | } 30 | return null; 31 | } 32 | 33 | /* 34 | * This method performs validation for fields one by one and 35 | * add the invalid one into a list if found and returns that list. 36 | */ 37 | public List executeAndGetList(UserInput userInput) { 38 | ValidationStrategy userValidation = UserValidationStrategy.UNSUPPORTED; 39 | List validatedTypes = new ArrayList(); 40 | for (Iterator iterator = userValidationStrategies.iterator(); iterator.hasNext();) { 41 | userValidation = iterator.next(); 42 | if (userValidation.validate(userInput)) { 43 | validatedTypes.add(userValidation.getValidationType()); 44 | } 45 | } 46 | return validatedTypes; 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /src/main/java/com/validation/enumuse/UserValidationStrategy.java: -------------------------------------------------------------------------------- 1 | 2 | package com.validation.enumuse; 3 | 4 | import com.calculator.enumuse.CalculatorInput; 5 | import com.calculator.enumuse.InvalidOperationException; 6 | import constants.ValidationType; 7 | 8 | import java.util.ArrayList; 9 | import java.util.Iterator; 10 | import java.util.List; 11 | import java.util.Set; 12 | 13 | public enum UserValidationStrategy implements ValidationStrategy { 14 | 15 | DATE_OF_BIRTH (ValidationType.DATE_OF_BIRTH) { 16 | public boolean validate(T input) { 17 | if(input.isUserValid() && input.getDateOfBirth().isEmpty() ) { 18 | return true; 19 | } 20 | return false; 21 | } 22 | }, 23 | 24 | CITY (ValidationType.CITY) { 25 | public boolean validate(T input) { 26 | if(input.isUserValid() && input.getCity().isEmpty() ) { 27 | return true; 28 | } 29 | return false; 30 | } 31 | }, 32 | 33 | ZIP (ValidationType.ZIP) { 34 | public boolean validate(T input) { 35 | if(input.isUserValid() && input.getZip().isEmpty() ) { 36 | return true; 37 | } 38 | return false; 39 | } 40 | }, 41 | 42 | COUNTRY (ValidationType.COUNTRY) { 43 | public boolean validate(T input) { 44 | if(input.isUserValid() && input.getCountry().isEmpty() ) { 45 | return true; 46 | } 47 | return false; 48 | } 49 | }, 50 | 51 | SSN (ValidationType.SSN) { 52 | public boolean validate(T input) { 53 | if(input.isUserValid() && input.getSsn().isEmpty() ) { 54 | return true; 55 | } 56 | return false; 57 | } 58 | }, 59 | 60 | CREDIT_CARD_NUMBER (ValidationType.CREDIT_CARD_NUMBER) { 61 | public boolean validate(T input) { 62 | if(input.isUserValid() && input.isCreditCardAdded() && input.getCreditCardNumber().isEmpty() ) { 63 | return true; 64 | } 65 | return false; 66 | } 67 | }, 68 | 69 | BANK_ROUTING_NUMBER (ValidationType.BANK_ROUTING_NUMBER) { 70 | public boolean validate(T input) { 71 | if(input.isUserValid() && input.isBankAdded() && input.getBankRoutingNumber().isEmpty() ) { 72 | return true; 73 | } 74 | return false; 75 | } 76 | }, 77 | 78 | BANK_ACCOUNT_NUMBER (ValidationType.BANK_ACCOUNT_NUMBER) { 79 | public boolean validate(T input) { 80 | if(input.isUserValid() && input.isBankAdded() && input.getBankAccountNumber().isEmpty() ) { 81 | return true; 82 | } 83 | return false; 84 | } 85 | }, 86 | 87 | BANK_NAME (ValidationType.BANK_NAME) { 88 | public boolean validate(T input) { 89 | if(input.isUserValid() && input.isBankAdded() && input.getBankName().isEmpty() ) { 90 | return true; 91 | } 92 | return false; 93 | } 94 | }, 95 | 96 | BANK_CITY (ValidationType.BANK_CITY) { 97 | public boolean validate(T input) { 98 | if(input.isUserValid() && input.isBankAdded() && input.getBankCity().isEmpty() ) { 99 | return true; 100 | } 101 | return false; 102 | } 103 | }, 104 | 105 | BANK_ZIP (ValidationType.BANK_ZIP) { 106 | public boolean validate(T input) { 107 | if(input.isUserValid() && input.isBankAdded() && input.getBankZip().isEmpty() ) { 108 | return true; 109 | } 110 | return false; 111 | } 112 | }, 113 | 114 | BANK_COUNTRY (ValidationType.BANK_COUNTRY) { 115 | public boolean validate(T input) { 116 | if(input.isUserValid() && input.isBankAdded() && input.getBankCountry().isEmpty() ) { 117 | return true; 118 | } 119 | return false; 120 | } 121 | }, 122 | 123 | UNSUPPORTED (ValidationType.UNSUPPORTED) { 124 | public boolean validate(T input) { 125 | return false; 126 | } 127 | }; 128 | 129 | private ValidationType validationType; 130 | 131 | private UserValidationStrategy(ValidationType validationType) { 132 | this.validationType = validationType; 133 | } 134 | 135 | public ValidationType getValidationType() { 136 | return validationType; 137 | } 138 | } 139 | -------------------------------------------------------------------------------- /src/main/java/com/validation/enumuse/ValidationStrategy.java: -------------------------------------------------------------------------------- 1 | package com.validation.enumuse; 2 | 3 | import constants.ValidationType; 4 | 5 | public interface ValidationStrategy { 6 | boolean validate(T input); 7 | ValidationType getValidationType(); 8 | } 9 | -------------------------------------------------------------------------------- /src/main/java/constants/OperationType.java: -------------------------------------------------------------------------------- 1 | package constants; 2 | 3 | public enum OperationType { 4 | ADDITION("+"), 5 | SUBTRACTION("-"), 6 | MULTIPLICATION("*"), 7 | DIVISION("/"); 8 | 9 | private String value; 10 | private OperationType(String value) { 11 | this.value = value; 12 | } 13 | 14 | public String getValue() { 15 | return value; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/main/java/constants/ValidationType.java: -------------------------------------------------------------------------------- 1 | package constants; 2 | 3 | public enum ValidationType { 4 | DATE_OF_BIRTH, 5 | CITY, 6 | ZIP, 7 | COUNTRY, 8 | SSN, 9 | CREDIT_CARD_NUMBER, 10 | BANK_ROUTING_NUMBER, 11 | BANK_ACCOUNT_NUMBER, 12 | BANK_NAME, 13 | BANK_CITY, 14 | BANK_ZIP, 15 | BANK_COUNTRY, 16 | BANK_ACCOUNT_TYPE, 17 | UNSUPPORTED 18 | 19 | } 20 | -------------------------------------------------------------------------------- /src/test/java/com/calculator/enumuse/CalculatorTest.java: -------------------------------------------------------------------------------- 1 | package com.calculator.enumuse; 2 | 3 | import constants.OperationType; 4 | import org.junit.Assert; 5 | import org.junit.Test; 6 | 7 | import javax.management.OperationsException; 8 | import java.util.HashSet; 9 | import java.util.Set; 10 | 11 | public class CalculatorTest { 12 | 13 | @Test 14 | public void testCalculatorOperationForADD() { 15 | Set calculatorStrategies = new HashSet(); 16 | calculatorStrategies.add(CalculatorOperationStrategy.ADD); 17 | calculatorStrategies.add(CalculatorOperationStrategy.SUBTRACTION); 18 | calculatorStrategies.add(CalculatorOperationStrategy.MULTIPLICATION); 19 | calculatorStrategies.add(ExtendedCalculatorOperationStrategy.DIVISION); 20 | 21 | CalculatorInput input = new CalculatorInput("+", 10, 5); 22 | CalculatorContext ctxCalculator = new CalculatorContext(calculatorStrategies); 23 | Assert.assertEquals(15, ctxCalculator.execute(input)); 24 | } 25 | 26 | @Test 27 | public void testCalculatorOperationForSUB() { 28 | Set calculatorStrategies = new HashSet(); 29 | calculatorStrategies.add(CalculatorOperationStrategy.ADD); 30 | calculatorStrategies.add(CalculatorOperationStrategy.SUBTRACTION); 31 | calculatorStrategies.add(CalculatorOperationStrategy.MULTIPLICATION); 32 | calculatorStrategies.add(ExtendedCalculatorOperationStrategy.DIVISION); 33 | 34 | CalculatorInput input = new CalculatorInput("-", 10, 5); 35 | CalculatorContext ctxCalculator = new CalculatorContext(calculatorStrategies); 36 | Assert.assertEquals(5, ctxCalculator.execute(input)); 37 | } 38 | 39 | @Test 40 | public void testCalculatorOperationForMUL() { 41 | Set calculatorStrategies = new HashSet(); 42 | calculatorStrategies.add(CalculatorOperationStrategy.ADD); 43 | calculatorStrategies.add(CalculatorOperationStrategy.SUBTRACTION); 44 | calculatorStrategies.add(CalculatorOperationStrategy.MULTIPLICATION); 45 | calculatorStrategies.add(ExtendedCalculatorOperationStrategy.DIVISION); 46 | 47 | CalculatorInput input = new CalculatorInput("*", 10, 5); 48 | CalculatorContext ctxCalculator = new CalculatorContext(calculatorStrategies); 49 | Assert.assertEquals(50, ctxCalculator.execute(input)); 50 | } 51 | 52 | @Test(expected = InvalidOperationException.class) 53 | public void testCalculatorOperationUnsupported() { 54 | Set calculatorStrategies = new HashSet(); 55 | calculatorStrategies.add(CalculatorOperationStrategy.ADD); 56 | calculatorStrategies.add(CalculatorOperationStrategy.SUBTRACTION); 57 | //Now, we decided not to support multiplication 58 | //calculatorStrategies.add(CalculatorOperation.MULTIPLICATION); 59 | calculatorStrategies.add(ExtendedCalculatorOperationStrategy.DIVISION); 60 | 61 | CalculatorInput input = new CalculatorInput("*", 10, 5); 62 | CalculatorContext ctxCalculator = new CalculatorContext(calculatorStrategies); 63 | ctxCalculator.execute(input); 64 | } 65 | 66 | @Test 67 | public void testCalculatorOperationForDIV() { 68 | Set calculatorStrategies = new HashSet(); 69 | calculatorStrategies.add(CalculatorOperationStrategy.ADD); 70 | calculatorStrategies.add(CalculatorOperationStrategy.SUBTRACTION); 71 | calculatorStrategies.add(CalculatorOperationStrategy.MULTIPLICATION); 72 | calculatorStrategies.add(ExtendedCalculatorOperationStrategy.DIVISION); 73 | 74 | CalculatorInput input = new CalculatorInput("/", 10, 5); 75 | CalculatorContext ctxCalculator = new CalculatorContext(calculatorStrategies); 76 | Assert.assertEquals(2, ctxCalculator.execute(input)); 77 | } 78 | 79 | } 80 | -------------------------------------------------------------------------------- /src/test/java/com/validator/enumuse/ValidatorTest.java: -------------------------------------------------------------------------------- 1 | package com.validator.enumuse; 2 | 3 | import com.validation.enumuse.*; 4 | import constants.ValidationType; 5 | import org.junit.Assert; 6 | import org.junit.Test; 7 | 8 | import java.util.HashSet; 9 | import java.util.LinkedHashSet; 10 | import java.util.Set; 11 | 12 | public class ValidatorTest { 13 | 14 | @Test 15 | public void testValidatorForDOB() { 16 | Set strategies = new LinkedHashSet(); 17 | strategies.add(UserValidationStrategy.DATE_OF_BIRTH); 18 | strategies.add(UserValidationStrategy.CITY); 19 | strategies.add(UserValidationStrategy.ZIP); 20 | strategies.add(UserValidationStrategy.COUNTRY); 21 | strategies.add(UserValidationStrategy.SSN); 22 | strategies.add(UserValidationStrategy.CREDIT_CARD_NUMBER); 23 | strategies.add(UserValidationStrategy.BANK_ROUTING_NUMBER); 24 | strategies.add(UserValidationStrategy.BANK_ACCOUNT_NUMBER); 25 | strategies.add(UserValidationStrategy.BANK_NAME); 26 | strategies.add(UserValidationStrategy.BANK_CITY); 27 | strategies.add(UserValidationStrategy.BANK_ZIP); 28 | strategies.add(UserValidationStrategy.BANK_COUNTRY); 29 | 30 | UserInput input = new UserInput(); 31 | input.setUserValid(true); 32 | input.setDateOfBirth(""); 33 | UserValidationContext ctxUser = new UserValidationContext(strategies); 34 | Assert.assertEquals(ValidationType.DATE_OF_BIRTH, ctxUser.execute(input)); 35 | } 36 | 37 | @Test 38 | public void testValidatorForCITY() { 39 | Set strategies = new LinkedHashSet(); 40 | strategies.add(UserValidationStrategy.DATE_OF_BIRTH); 41 | strategies.add(UserValidationStrategy.CITY); 42 | strategies.add(UserValidationStrategy.ZIP); 43 | strategies.add(UserValidationStrategy.COUNTRY); 44 | strategies.add(UserValidationStrategy.SSN); 45 | strategies.add(UserValidationStrategy.CREDIT_CARD_NUMBER); 46 | strategies.add(UserValidationStrategy.BANK_ROUTING_NUMBER); 47 | strategies.add(UserValidationStrategy.BANK_ACCOUNT_NUMBER); 48 | strategies.add(UserValidationStrategy.BANK_NAME); 49 | strategies.add(UserValidationStrategy.BANK_CITY); 50 | strategies.add(UserValidationStrategy.BANK_ZIP); 51 | strategies.add(UserValidationStrategy.BANK_COUNTRY); 52 | 53 | UserInput input = new UserInput(); 54 | input.setUserValid(true); 55 | input.setDateOfBirth("01/01/1990"); 56 | input.setCity(""); 57 | UserValidationContext ctxUser = new UserValidationContext(strategies); 58 | Assert.assertEquals(ValidationType.CITY, ctxUser.execute(input)); 59 | } 60 | 61 | @Test 62 | public void testValidatorForUNSUPPORTED_DOB() { 63 | Set strategies = new LinkedHashSet(); 64 | //strategies.add(UserValidation.DATE_OF_BIRTH); 65 | strategies.add(UserValidationStrategy.CITY); 66 | strategies.add(UserValidationStrategy.ZIP); 67 | 68 | UserInput input = new UserInput(); 69 | input.setUserValid(true); 70 | input.setDateOfBirth(""); 71 | input.setCity(""); 72 | input.setZip(""); 73 | UserValidationContext ctxUser = new UserValidationContext(strategies); 74 | Assert.assertEquals(ValidationType.CITY, ctxUser.execute(input)); 75 | } 76 | 77 | @Test 78 | public void testValidatorForGetList() { 79 | Set strategies = new LinkedHashSet(); 80 | strategies.add(UserValidationStrategy.DATE_OF_BIRTH); 81 | strategies.add(UserValidationStrategy.CITY); 82 | strategies.add(UserValidationStrategy.ZIP); 83 | strategies.add(UserValidationStrategy.COUNTRY); 84 | strategies.add(UserValidationStrategy.SSN); 85 | strategies.add(UserValidationStrategy.CREDIT_CARD_NUMBER); 86 | strategies.add(UserValidationStrategy.BANK_ROUTING_NUMBER); 87 | strategies.add(UserValidationStrategy.BANK_ACCOUNT_NUMBER); 88 | strategies.add(UserValidationStrategy.BANK_NAME); 89 | strategies.add(UserValidationStrategy.BANK_CITY); 90 | strategies.add(UserValidationStrategy.BANK_ZIP); 91 | strategies.add(UserValidationStrategy.BANK_COUNTRY); 92 | 93 | UserInput input = new UserInput(); 94 | input.setUserValid(true); 95 | input.setDateOfBirth("01/01/1990"); 96 | input.setCity("SanJose"); 97 | input.setZip(""); 98 | input.setCountry("USA"); 99 | input.setSsn(""); 100 | input.setBankAdded(true); 101 | input.setCreditCardAdded(true); 102 | input.setCreditCardNumber(""); 103 | input.setBankRoutingNumber(""); 104 | input.setBankAccountNumber(""); 105 | input.setBankName(""); 106 | input.setBankCity(""); 107 | input.setBankZip(""); 108 | input.setBankCountry(""); 109 | UserValidationContext ctxUser = new UserValidationContext(strategies); 110 | Object[] arrResultActual = ctxUser.executeAndGetList(input).toArray(); 111 | Object[] arrResultExpected = {ValidationType.ZIP, ValidationType.SSN, ValidationType.CREDIT_CARD_NUMBER, ValidationType.BANK_ROUTING_NUMBER, ValidationType.BANK_ACCOUNT_NUMBER, ValidationType.BANK_NAME, ValidationType.BANK_CITY, ValidationType.BANK_ZIP, ValidationType.BANK_COUNTRY}; 112 | 113 | Assert.assertArrayEquals(arrResultExpected, arrResultActual); 114 | } 115 | 116 | @Test 117 | public void testValidatorForAllValidAndGetList() { 118 | Set strategies = new LinkedHashSet(); 119 | strategies.add(UserValidationStrategy.DATE_OF_BIRTH); 120 | strategies.add(UserValidationStrategy.CITY); 121 | strategies.add(UserValidationStrategy.ZIP); 122 | strategies.add(UserValidationStrategy.COUNTRY); 123 | strategies.add(UserValidationStrategy.SSN); 124 | strategies.add(UserValidationStrategy.CREDIT_CARD_NUMBER); 125 | strategies.add(UserValidationStrategy.BANK_ROUTING_NUMBER); 126 | strategies.add(UserValidationStrategy.BANK_ACCOUNT_NUMBER); 127 | strategies.add(UserValidationStrategy.BANK_NAME); 128 | strategies.add(UserValidationStrategy.BANK_CITY); 129 | strategies.add(UserValidationStrategy.BANK_ZIP); 130 | strategies.add(UserValidationStrategy.BANK_COUNTRY); 131 | 132 | UserInput input = new UserInput(); 133 | input.setUserValid(true); 134 | input.setDateOfBirth("01/01/1990"); 135 | input.setCity("SanJose"); 136 | input.setZip("95131"); 137 | input.setCountry("USA"); 138 | input.setSsn("123-45-6789"); 139 | input.setBankAdded(true); 140 | input.setCreditCardAdded(true); 141 | input.setCreditCardNumber("123456789"); 142 | input.setBankRoutingNumber("123456789"); 143 | input.setBankAccountNumber("12345678898"); 144 | input.setBankName("Abc"); 145 | input.setBankCity("SanJose"); 146 | input.setBankZip("95131"); 147 | input.setBankCountry("USA"); 148 | UserValidationContext ctxUser = new UserValidationContext(strategies); 149 | Object[] arrResultActual = ctxUser.executeAndGetList(input).toArray(); 150 | Object[] arrResultExpected = {}; 151 | Assert.assertArrayEquals(arrResultExpected, arrResultActual); 152 | } 153 | 154 | @Test 155 | public void testValidatorForAllValid() { 156 | Set strategies = new LinkedHashSet(); 157 | strategies.add(UserValidationStrategy.DATE_OF_BIRTH); 158 | strategies.add(UserValidationStrategy.CITY); 159 | strategies.add(UserValidationStrategy.ZIP); 160 | strategies.add(UserValidationStrategy.COUNTRY); 161 | strategies.add(UserValidationStrategy.SSN); 162 | strategies.add(UserValidationStrategy.CREDIT_CARD_NUMBER); 163 | strategies.add(UserValidationStrategy.BANK_ROUTING_NUMBER); 164 | strategies.add(UserValidationStrategy.BANK_ACCOUNT_NUMBER); 165 | strategies.add(UserValidationStrategy.BANK_NAME); 166 | strategies.add(UserValidationStrategy.BANK_CITY); 167 | strategies.add(UserValidationStrategy.BANK_ZIP); 168 | strategies.add(UserValidationStrategy.BANK_COUNTRY); 169 | 170 | UserInput input = new UserInput(); 171 | input.setUserValid(true); 172 | input.setDateOfBirth("01/01/1990"); 173 | input.setCity("SanJose"); 174 | input.setZip("95131"); 175 | input.setCountry("USA"); 176 | input.setSsn("123-45-6789"); 177 | input.setBankAdded(true); 178 | input.setCreditCardAdded(true); 179 | input.setCreditCardNumber("123456789"); 180 | input.setBankRoutingNumber("123456789"); 181 | input.setBankAccountNumber("12345678898"); 182 | input.setBankName("Abc"); 183 | input.setBankCity("SanJose"); 184 | input.setBankZip("95131"); 185 | input.setBankCountry("USA"); 186 | UserValidationContext ctxUser = new UserValidationContext(strategies); 187 | Assert.assertNull(ctxUser.execute(input)); 188 | } 189 | 190 | @Test 191 | public void testValidatorForUNSUPPORTED() { 192 | Set strategies = new LinkedHashSet(); 193 | strategies.add(UserValidationStrategy.DATE_OF_BIRTH); 194 | //strategies.add(UserValidationStrategy.CITY); 195 | strategies.add(UserValidationStrategy.ZIP); 196 | //strategies.add(UserValidation.COUNTRY); 197 | strategies.add(UserValidationStrategy.SSN); 198 | //strategies.add(UserValidation.CREDIT_CARD_NUMBER); 199 | strategies.add(UserValidationStrategy.BANK_ROUTING_NUMBER); 200 | strategies.add(UserValidationStrategy.BANK_ACCOUNT_NUMBER); 201 | //strategies.add(UserValidation.BANK_NAME); 202 | //strategies.add(UserValidation.BANK_CITY); 203 | //strategies.add(UserValidation.BANK_ZIP); 204 | //strategies.add(UserValidation.BANK_COUNTRY); 205 | 206 | UserInput input = new UserInput(); 207 | input.setUserValid(true); 208 | input.setDateOfBirth(""); 209 | input.setCity("SanJose"); 210 | input.setZip("95131"); 211 | input.setCountry("USA"); 212 | input.setSsn(""); 213 | input.setBankAdded(true); 214 | input.setCreditCardAdded(true); 215 | input.setCreditCardNumber(""); 216 | input.setBankRoutingNumber("123456789"); 217 | input.setBankAccountNumber(""); 218 | input.setBankName(""); 219 | input.setBankCity(""); 220 | input.setBankZip(""); 221 | input.setBankCountry(""); 222 | UserValidationContext ctxUser = new UserValidationContext(strategies); 223 | Object[] arrResultActual = ctxUser.executeAndGetList(input).toArray(); 224 | Object[] arrResultExpected = {ValidationType.DATE_OF_BIRTH, ValidationType.SSN, ValidationType.BANK_ACCOUNT_NUMBER}; 225 | Assert.assertArrayEquals(arrResultExpected, arrResultActual); 226 | } 227 | 228 | @Test 229 | public void testValidatorForExtension() { 230 | Set strategies = new LinkedHashSet(); 231 | strategies.add(UserValidationStrategy.DATE_OF_BIRTH); 232 | strategies.add(ExtendedValidationStrategy.BANK_ACCOUNT_TYPE); 233 | 234 | UserInput input = new UserInput(); 235 | input.setUserValid(true); 236 | input.setDateOfBirth("01/01/1994"); 237 | input.setBankAdded(true); 238 | input.setBankAccountType(""); 239 | UserValidationContext ctxUser = new UserValidationContext(strategies); 240 | Assert.assertEquals(ValidationType.BANK_ACCOUNT_TYPE, ctxUser.execute(input)); 241 | } 242 | } 243 | --------------------------------------------------------------------------------