1. Overview

In this tutorial, we’ll show how to generate Java objects with theEasyRandom library.

2. EasyRandom

In some cases, we need a set of model objects that we’ll use for testing purposes. Or, we’d like to populate our test database with some data we’re going to make use of. Then, maybe we’d want to have collections of dummy DTOs to send back to our client.

Setting up one, two or a few such objects might be easy if they’re not complex. Yet, there might be a case when we’d need hundreds of them immediately, without getting our hands dirty with manual setup.

Here’s whereEasyRandom steps in. EasyRandom is alibrary that’s easy to use, requires little to nothing set up and just bypassing the class type, it’s gonna instantiate whole object graphs for us.

Let’s see how easy it is.

3. Maven Dependency

First, let’s addthe easy-random-core Maven dependency to ourpom.xml:

<dependency>    <groupId>org.jeasy</groupId>    <artifactId>easy-random-core</artifactId>    <version>4.0.0</version></dependency>

4. Objects Generation

The two most important classes in the library are:

• EasyRandom that’s going to generate the objects, and
• EasyRandomParameters that allows us to configure the generation process and make it more predictable.

4.1. Single Object

Our first example generates a simple randomPerson object that has no nested objects, no collections, just anInteger, and twoStrings.

Let’sgenerate one instance of our object usingnextObject(Class<T> t):

@Testvoid givenDefaultConfiguration_thenGenerateSingleObject() {    EasyRandom generator = new EasyRandom();    Person person = generator.nextObject(Person.class);    assertNotNull(person.getAge());    assertNotNull(person.getFirstName());    assertNotNull(person.getLastName());}

This is how the object might look after the generation:

Person[firstName='eOMtThyhVNLWUZNRcBaQKxI', lastName='yedUsFwdkelQbxeTeQOvaScfqIOOmaa', age=-1188957731]

As we can see, generated strings might be a bit too long, and age is negative. We’ll show how this can be tweaked in further sections.

4.2. A Collection of Objects

Now, let’s say we need a collection of Person objects. Another method, objects(Class<T> t, int size) will allow us to do so.

A nice thing is, it returns stream of objects, so eventually,we could add intermediate operations to it or group as we want.

Here’s how we couldgenerate five instances ofPerson:

@Testvoid givenDefaultConfiguration_thenGenerateObjectsList() {    EasyRandom generator = new EasyRandom();    List<Person> persons = generator.objects(Person.class, 5)        .collect(Collectors.toList());    assertEquals(5, persons.size());}

4.3. Complex Objects Generation

Let’s have a look at our Employee class:

public class Employee {    private long id;    private String firstName;    private String lastName;    private Department department;    private Collection<Employee> coworkers;    private Map<YearQuarter, Grade> quarterGrades;}

Our class is relatively complex, it has a nested object, a collection, and a map.

Now by default,the collection generation range is from 1 to 100, so our Collection<Employee>size would result in between.

A good thing is, theobjects are going to be cached and re-used, so not necessarily all are unique. Still, we might not need so many.

We’ll soon take a look at how to adjust the collection’s range, but first, let’s see at another issue we might run into.

In our domain, we have aYearQuarter class that represents a quarter of a year.

There’s a bit of logic toset up theendDate to point exactly to 3 months after the start date:

public class YearQuarter {    private LocalDate startDate;    private LocalDate endDate;    public YearQuarter(LocalDate startDate) {        this.startDate = startDate;        autoAdjustEndDate();    }    private void autoAdjustEndDate() {        endDate = startDate.plusMonths(3L);    }}

We must note,EasyRandom uses reflection to construct our objects, so generating this object through the library will result in data that, most likely,won’t be useful for us as our constraint of 3 months simply won’t be preserved.

Let’s have a look at how we could address this issue.

4.4. Generation Configuration

In the below configuration, we supply ourcustom configuration viaEasyRandomParameters.

First, we explicitly state our desired string length and collections size. Next, we exclude some of the fields from generation, let’s say we had a reason to have just nulls.

Here, we’ve used the handyFieldPredicates utility to chain the exclusion predicates.

After that, we exclude everything from“not.existing.pkg”Java package, through another handyTypePredicatesutility.

And finally, as promised, we address the issue with startDateand endDate generation of YearQuarter class by applying our custom YearQuarterRandomizer:

@Testvoid givenCustomConfiguration_thenGenerateSingleEmployee() {    EasyRandomParameters parameters = new EasyRandomParameters();    parameters.stringLengthRange(3, 3);    parameters.collectionSizeRange(5, 5);    parameters.excludeField(FieldPredicates.named("lastName").and(FieldPredicates.inClass(Employee.class)));    parameters.excludeType(TypePredicates.inPackage("not.existing.pkg"));    parameters.randomize(YearQuarter.class, new YearQuarterRandomizer());    EasyRandom generator = new EasyRandom(parameters);    Employee employee = generator.nextObject(Employee.class);    assertEquals(3, employee.getFirstName().length());    assertEquals(5, employee.getCoworkers().size());    assertEquals(5, employee.getQuarterGrades().size());    assertNotNull(employee.getDepartment());    assertNull(employee.getLastName());    for (YearQuarter key : employee.getQuarterGrades().keySet()) {        assertEquals(key.getStartDate(), key.getEndDate().minusMonths(3L));    }}

5. Conclusion

Manually setting up a model, DTO or entity objects might be cumbersome and result in less readable code and duplications. EasyRandom is a nice tool that can save time and help with it.

As we saw, the library doesn’t generate meaningfulString objects, but there’s another tool calledJava Faker with which we could create custom randomizers for the fields to sort it out as well.

Also, to have a deeper view of the library and see how much more it can be configured, we might have a look at itsGithub Wiki page.