Reflection Object Factory

Reflection Object Factory (ROF) is a Java library which simplifies the process of creating randomized data objects for testing.

Simple creation of data objects

Creation of complex data types to use as inputs, mock outputs, etc. during a test can be time-consuming and tedious. Object Factory instantiates fully populated complex data types in a single line of code, which can be placed in the test itself to achieve clear and concise test setup.

Randomized test data

Most well-design software components aren't tightly coupled with exact input values. The tests for these components don't need to (and arguably shouldn't) depend on exact values or static data in order to exercise and verify the contract of the component under test. Designing components to be testable with random data tends to promote more generic and reusable software. Object Factory makes it easy to test with random valid values, and allows the user to configure the shape of valid values if necessary.

Artifacts

Maven

<dependency>
    <groupId>com.amazon.datagen</groupId>
    <artifactId>objectfactory_2.11</artifactId>
    <version>1.0</version>
</dependency>

Gradle

compile group: 'com.amazon.datagen', name: 'objectfactory_2.11', version: '1.0'

SBT

libraryDependencies += "com.amazon.datagen" % "objectfactory" % "1.0"

Usage

Reflection object factory is fairly easy to use:

Create objects

    // Instantiate object factory
    final ObjectFactory factory = new ReflectionObjectFactory();
    
    // Create an instance of FooInput populated with random values
    final FooInput input = factory.create(FooInput.class);
    
    // Create a set of instances of Bar populated with random values
    final Set<Bar> bars = factory.setOf(Bar.class);

Initialization

Local Instance

Object Factory provides a default constructor and a constructor which takes a configuration object (see Customization).

// Default instance
final ObjectFactory factory = new ReflectionObjectFactory();
 
// Configured instance
final Config config = Config.createDefault();
final ObjectFactory factory = new ReflectionObjectFactory(config);

Inheritance

Object Factory provides an abstract class wrapper for convenience that can be inherited by test classes.

public final Class FooTest extends AbstractObjectFactory {
    
    @Test
    public void testBar() {
        final BarInput input = create(BarInput.class);  // inherited from AbstractObjectFactory
        
        ...
    }
}

Supported Class Types

Object factory supports following types of object creation:

• Primitives
  • boolean, byte, char, double, float, int, long, short
  • Boolean, Byte, Character, Double, Float, Integer, Long, Short, String, Date, BigInteger, BigDecimal
  • Array of any of above such as int[] or Integer[]
• Plan Old Java Object (POJO)
• Optional of any of above such as Optional<Integer>
• Abstract Class Proxy
  • Note: only abstract with empty parameter constructor is supported
• Interface Proxy

Note

• When calling a method from Proxied abstract class/interface, each time the return value is randomized by default.
• You can use Config.withSupplier to customize how the return value is generated for specific method.
• Customized type can also be add through Config class. See Customization

Customization

Customize Primitive Creation

By default reflection object factory contains a set of suppliers that can create different primitives. For the full list of primitives and the suppliers, refer to primitive supplier. Here is an example to override the existing primitive supplier:

final Config config = Config.createDefault()
                .withSupplier(int.class, new IncrementalIntSupplier(0));
final int[] incrementalIntegers = new ReflectionObjectFactory(config).create(int[].class);

Customize Array Size

The size of array could be set up in the following way:

    final int minSize = 20;
    final int maxSize = 30;
    final Config config = Config.createDefault()
	                    .withArraySizeSupplier(new MinMaxIntegerSupplier(minSize, maxSize));
    final String[] randomStrings = new ReflectionObjectFactory(config).create(String[].class);

Customize Your Own Class as Primitive

Primitives are the building block to create object, but their types are not limited to integer, double, etc. Supplier for any class could be added into configuration to be treated as a building block, so that the supplier will be used first before factory looks into the constructor of that class.

Example:

final Config config = Config.createDefault()
        .withSupplier(Offer.class, new OfferSupplier());
final Merchant merchant = new ReflectionObjectFactory(config).create(Merchant.class);

• Note: When overriding primitives such as int and Integer, they are treated as different classes, which means if POJO class has int field use int.class in withSupplier method.

License

This tool is under Apache License Version 2.0