# Testing Business Entity Validation

To test our validation, a test class needs to be created. The one-off generation process has created one for each of the existing entities in the system. The following is the one it created for the Characteristic Type entity:

    			public class CharacteristicType_Test extends AbstractEntityTestCase {

    			    private static Logger logger = LoggerFactory.getLogger(CharacteristicType_Test.class);

    			    /**
    			      * @see com.splwg.base.api.testers.AbstractEntityTestCase#getChangeHandlerClass()
    			      */
    			    protected Class getChangeHandlerClass() {
    			        return CharacteristicType_CHandler.class;
    			    }
    			}

This is a JUnit test case. Let's run it. From within Eclipse, right-click on the test class from within the Package Explorer.

The following image shows the resulting output from JUnit:

As we see, the tests failed and told us that none of our three validation rules where validated. This is, of course true, but some explanation is necessary. When we run entity test cases, the framework looks up the change handler class being tested and collects all its rules. Then it executes all the tests in the test class (basically every method starting with test*). At the end of each test, it looks to see if the last rule violated was one of the rules we are testing. At the end of all the tests, if there are still validation rules that weren't violated, the framework complains. At a minimum, the goal from this point is to create tests that violate each of our rules at least once. Preferably, tests should be created to violate the rules for all additional conditions that we can think of that might compromise the state of the entity.

Let's start fixing the tests with the Foreign Key Reference is required for FK Characteristic Values rule. With a little head-scratching we determine that this is a RequireRule and we replace it as shown below:

    			public static ValidationRule
    			        foreignKeyReferencesRequiredForFkCharValueRule(){
    			    return RequireRule...someFactoryMethod...(
    			        "CharacteristicType:Foreign Key Reference is required for FK
    			             Characteristic Values",
    			        "If the Characteristic Type Lookup is 'Foreign Key Value' then the
    			             Foreign Key Reference Cd is required",
    			      ... some fancy stuff ....
    			        fkReferencesRequiredForFKCharacteristicValueMessage);
    			}

Here's the test that was added to the test class to test it:

    			    /** Test foreignKeyReferencesRequiredForFkCharValueRule  */
    			    public void testFKReferencesOnlyForFKCharacteristics() {
    			        // create a new characteristic type
    			        CharacteristicType charType = createNewTestObject();
    			        CharacteristicType_DTO charTypeDTO = charType.getDTO();

    			        // set the characteristic value to null for some other type
    			        charTypeDTO.setForeignKeyReference("");
    			        charTypeDTO.setCharacteristicType
    			              (CharacteristicTypeLookup.PREDEFINEDVALUE);

    			        // this should be OK
    			        charType.setDTO(charTypeDTO);

    			        // Now make it a FK characteristic.  This should violated the rule
    			        charTypeDTO.setCharacteristicType
    			              (CharacteristicTypeLookup.FOREIGNKEYVALUE);
    			        try {
    			            charType.setDTO(charTypeDTO);
    			            fail("An error should have been thrown");
    			        } catch (ApplicationException e) {
    			            // Make sure the correct rule was violated.
    			            VerifyViolatedRule
    			               (CharacteristicType_CHandler.
    			               foreignKeyReferencesRequiredForFkCharValueRule());
    			        }
    			    }

Note: Important note: Both a valid test AND an invalid test were added to the method above.

Finally, when the test is rerun, we have one validation rule less needing to be violated.

Iterate Until Done

Parent topic: Standard test cases