Page Comparison

...

For repetitive testing of degenerate use of methods with null and INVALID values, a class DegenerateUseMethodTestHelper is provided, which includes two static methodsprovides a mechanism for testing a method

• A call with supplied valid parameters is made to verify that the method invocation can be successfully made
• For each parameter, the value is alternately set to null and a specified invalid value, the method is invoked, and behavior evaluated as described below

The four methods available for degenerate use testing are:

• DegenerateUseMethodTestHelper(Object o, Method m, Object[] parameters)
• DegenerateUseMethodTestHelper(Object o, Method m, Object[] parameters, Object[] invalidParameters)
• DegenerateUseMethodTestHelper(Object o, Method m, Object[] parameters, ExpectedFailures[] failureTypes)

...

• DegenerateUseMethodTestHelper(Object o, Method m, Object[] parameters,  Object[] invalidParameters), ExpectedFailures[] failureTypes)
  
  

Where:

• Object:  The service client undergoing testing
• Method:  The method of the service client to be tested
• Parameters:  An object array of values that that produce successful invocation of the method
• InvalidParameters (optional):  An object array of values which will be used to test invalid parameters for the method invocation
  • If not provided, the default values for class types are:
    • String: "" (empty string)
    • Long: -5L
    • Integer/int : -5
  • For all other classes, the invalid value is set to null, and is not tested.  If additional default behavior is desired, the Test Helper can be modified to create invalid objects.
• ExpectedFailures (optional):  An array of Enum constants ExpectedFailures
  The most common types used will be:EXCEPTIONNull
  • If not provided, the default behavior expected is EXCEPTION for both null and invalid values
  • The general behaviors that can be specified are:
    • EXCEPTION: Null and invalid values both throw exceptions.
    • If the ExpectedFailures array is not specified, this is the default behavior
    • SKIPBehavior SKIP: Behavior of this parameter will not be evaluated
    • NONENull : Null and invalid values should not throw exceptions
    • NO_RESULTSNull : Null and invalid values will both return no results
  • TypeValue-specific behavior:  Here.   
    
    NOTE:  This will be refactored to only require 9 enums spanning all combinations of (SUCCESS, EXCEPTION, NO RESULTS).  Invalid values will be parameterizable. 
    
    Here, differing behavior is expected from invalid and null values.  The following enums are named in the format TYPE_PARAMETER1_RESULT1_PARAMETER2_RESULT2.  For each of these cases, the parameter passed in is checked for type safety, and behavior evaluated according to the result for each parameter.
    • Class:  Long
      • Invalid value is -5L;
      • Available enums are:
        • LONG_INVALID_NO_RESULTS_NULL_EXCEPTION
          • For an invalid Long value, no results should be returned
          • For a null Long value, an exception should be thrown
    • Class: String
      Invalid value is "";
      • Available enums are:
        • STRING_INVALID_EXCEPTION_NULL_EXCEPTION
          • For both INVALID and null String values, an exception should be thrown
          • This is identical to EXCEPTION above, but restricted to String parameters
        • STRING_INVALID_EXCEPTION_NULL_NO_RESULTS
          • An INVALID string will cause an exception
          • A null string will return no results
        • STRING_INVALID_EXCEPTION_NULL_SUCCESS
          • An INVALID string will cause an exception
          • A null value will cause a successful invocation
        • STRING_INVALID_NO_RESULTS_NULL_EXCEPTION
          • An INVALID string will return no results
          • A null value will throw an exception
        • STRING_INVALID_NO_RESULTS_NULL_NO_RESULTS
          • Both INVALID strings and null values return no results.
        • STRING_INVALID_NO_RESULTS_NULL_SUCCESS
          • An INVALID string will return no results
          • A null value will cause a successful invocation
        • STRING_INVALID_SUCCESS_NULL_EXCEPTION
          • An INVALID string will cause a successful invocation
          • A null string will throw an exception
        • STRING_INVALID_SUCCESS_NULL_NO_RESULTS
          • An INVALID string will cause a successful invocation
          • A null string will return no results
        • STRING_INVALID_SUCCESS_NULL_SUCCESS
          • Both null and INVALID strings will cause a successful invocation
          • This is identical to NONE above, but restricted to String parameters
            
            

Paging/Filtering/Sorting objects (PfsParameter) are explicitly handled with the following tests:

• Test invalid sort field (specified by string "-")
• Test invalid start index (specified by integer -5);
• Test invalid query restriction (specified by string "BAD_SYNTAX*:*!~bad")

Example: 

SecurityClientRest service = new SecurityClientRest(ConfigUtility.getConfigProperties());
 
// use reflection to get the desired method
Method method =
        service.getClass().getMethod(
			"authenticate", 								// method name and parameters
			new Class<?>[] {String.class, String.class});	// i.e. SecurityClientRest.authenticate(String username, String password)
 
// specify the valid parameters
Object[] parameters = new Object[] {
        new String("name"), new String("password")			// valid parameters that when passed to method produce successful outcome (e.g. authentication)
    };
 
// if all invalid and null parameters should throw exceptions, use this call
DegenerateUseMethodTestHelper.testDegenerateArguments(service, method,
        parameters);
 
// if different parameters cause different behavior, use this type of call
DegenerateUseMethodTestHelper.testDegenerateArguments(service, method,
        parameters, new ExpectedFailure[] {
            ExpectedFailure.STRING_INVALID_NO_RESULTS_NULL_EXCEPTION, // an INVALID string will result in no result, a NULL string will result in exception
			ExpectedFailure.EXCEPTION								  // both INVALID strings and NULL strings will result in exception
        });
 
// if specific invalid values are desired, use this type of call
DegenerateUseMethodTestHelper.testDegenerateArguments(service, method,
        parameters, new Object[] {						
			new String("Invalid value"),					// the first argument should test "Invalid value", and the method should throw an exception
			null											// no invalid value will be tested
		});

References/Links

• http://en.wikipedia.org/wiki/Integration_testing

...