Add support to generate random Java Records

[fmbenhassine]

Java 14 introduced Records. It would be great if Easy Random can generate random instances of such types.

[fmbenhassine]

Since records are classes, EasyRandom is actually able to randomize them. Here is an example that works as expected with ER 4.3 and Java 14:

record Person(int id, String name) {}

public static void main(String[] args) {
   EasyRandom easyRandom = new EasyRandom();
   Person person = easyRandom.nextObject(Person.class);
   System.out.println("person.id = " + person.id());
   System.out.println("person.name = " + person.name());
   // prints:
   // person.id = -1188957731
   // person.name = eOMtThyhVNLWUZNRcBaQKxI
}

Minimal complete example: test-easy-random-records.zip

[mmaggioni-wise]

Hi @benas ,

it doesn't work with java 15.
it seems it's not possibile anymore to change record fields through reflection.

java.lang.IllegalAccessException: Can not set final field

https://mail.openjdk.java.net/pipermail/amber-dev/2020-June/006241.html
https://medium.com/@atdsqdjyfkyziqkezu/java-15-breaks-deserialization-of-records-902fcc81253d

[fmbenhassine]

Hi @mmaggioni-wise ,

Thank you for raising this. Indeed, things seem to have changed in Java 15. The fact that records are immutable is actually incompatible with the way Easy Random works which is creating an a new ("empty") instance of the target type and then populating its fields afterwards. With records, it should be the other way around: generate random values for record components (ie fields) then create an instance with those values. So I think this feature should not be implemented in Easy Random itself (given the impact this has on the current code/approach), but using a custom ObjectFactory for records. Here is a quick example:

package org.jeasy.random;

import java.lang.reflect.Constructor;
import java.lang.reflect.RecordComponent;

import org.jeasy.random.api.RandomizerContext;

public class RecordFactory extends ObjenesisObjectFactory {

	private EasyRandom easyRandom;

	@Override
	public <T> T createInstance(Class<T> type, RandomizerContext context) {
		if (easyRandom == null) {
			easyRandom = new EasyRandom(context.getParameters());
		}
		
		if (type.isRecord()) {
			return createRandomRecord(type);
		} else {
			return super.createInstance(type, context);
		}
	}

	private <T> T createRandomRecord(Class<T> recordType) {
                // generate random values for record components
		RecordComponent[] recordComponents = recordType.getRecordComponents();
		Object[] randomValues = new Object[recordComponents.length];
		for (int i = 0; i < recordComponents.length; i++) {
			randomValues[i] = easyRandom.nextObject(recordComponents[i].getType());
		}
                // create a random instance with random values
		try {
			return getCanonicalConstructor(recordType).newInstance(randomValues);
		} catch (Exception e) {
			throw new ObjectCreationException("Unable to create a random instance of recordType " + recordType, e);
		}
	}

	private <T> Constructor<T> getCanonicalConstructor(Class<T> recordType) {
		RecordComponent[] recordComponents = recordType.getRecordComponents();
		Class<?>[] componentTypes = new Class<?>[recordComponents.length];
		for (int i = 0; i < recordComponents.length; i++) {
			// recordComponents are ordered, see javadoc:
			// "The components are returned in the same order that they are declared in the record header"
			componentTypes[i] = recordComponents[i].getType();
		}
		try {
			return recordType.getDeclaredConstructor(componentTypes);
		} catch (NoSuchMethodException e) {
			// should not happen, from Record javadoc:
			// "A record class has the following mandated members: a public canonical constructor ,
			// whose descriptor is the same as the record descriptor;"
			throw new RuntimeException("Invalid record definition", e);
		}
	}
}

With this custom factory, the previous example works with Java 15 (assuming that the custom factory is passed to ER through parameters):

EasyRandomParameters parameters = new EasyRandomParameters()
		.objectFactory(new RecordFactory());
EasyRandom easyRandom = new EasyRandom(parameters);
// ...

Minimal complete example for reference: test-easy-random-records-custom-factory.zip

[mmaggioni-wise]

thank you @benas for your answer and your example!

[vab2048]

Thank you @benas. Are you sure that this should not be enabled by default for records (seeing as they will become a standard feature should easy-random not support them out of the box)? What would be the negatives of doing so?

[fmbenhassine]

@vab2048 It should, this is what I had in mind when I first created this issue. The idea was that easy random should be able to handle both regular classes and records in a transparent way. This was true with Java 14 (as shown in #397 (comment)), but unfortunately not anymore with Java 15 as reported by @mmaggioni-wise (it's ok that things break since java records are still in preview).

Records will be out of preview in Java 16. This means adding record support in ER in a transparent way (ie without a custom object factory) requires a major release that is based on Java 16 (there are techniques to do conditional compilation &co but I'm not ready to deal with that here). Even though that's fine in my opinion, it is a quite aggressive requirement, I remember some users were reluctant to making ER v5 based on Java 11 already, see dfbab94#r43985189).

But the real issue is not about the minimum required Java version. The issue is that since java records are immutable, they should be randomized in the opposite way of randomizing java beans (ie first generate random values then create a record instance with them vs create an empty bean instance then set random values on it). This requires a substantial amount of work to implement and test. I think it's unfortunate that ER does not support records OOTB after being declared in maintenance mode (this decision was made based on the assumption that records are already supported, which, I must admit, is a mistake since I should have expected things to break before this feature goes out of preview..). So I think it's wise to re-consider records support in ER v6 which would be based on Java 16 (in which records will be stable and we can expect no breaking changes as the ones introduced between 14 and 15). wdyt?

[vab2048]

@benas your idea of waiting until records become a standard feature makes perfect sense. With Java 16 due to be released in March 2021 and records becoming a standard feature (https://openjdk.java.net/projects/jdk/16/) perhaps this issue should remain open as a reminder for the future once it is released?

Until then the code example you provided works wonderfully with Java 15 and I suspect would also work with Java 16 - so we have an easy workaround.