A Guide to JavaFaker

1. Overview

JavaFaker is a library that can be used to generate a wide array of real-looking data from addresses to popular culture references.

In this tutorial, we’ll be looking at how to use JavaFaker’s classes to generate fake data. We’ll start by introducing the Faker class and the FakeValueService, before moving on to introducing locales to make the data more specific to a single place.

Finally, we’ll discuss how unique the data is. To test JavaFaker’s classes, we’ll make use of regular expressions, you can read more about them here.

2. Dependencies

Below is the single dependency we’ll need to get started with JavaFaker.

First, the dependency we’ll need for Maven-based projects:

<dependency>
    <groupId>com.github.javafaker</groupId>
    <artifactId>javafaker</artifactId>
    <version>0.15</version>
</dependency>

For Gradle users, you can add the following to your build.gradle file:

compile group: 'com.github.javafaker', name: 'javafaker', version: '0.15'

3. FakeValueService

The FakeValueService class provides methods for generating random sequences as well as resolving .yml files associated with the locale.

In this section, we’ll cover some of the useful methods that the FakerValueService has to offer.

3.1. Letterify, Numerify, and Bothify

Three useful methods are Letterify, Numberify, and Bothify. Letterify helps to generate random sequences of alphabetic characters.

Next, Numerify simply generates numeric sequences.

Finally, Bothify is a combination of the two and can create random alphanumeric sequences – useful for mocking things like ID strings.

FakeValueService requires a valid Locale, as well as a RandomService:

@Test
public void whenBothifyCalled_checkPatternMatches() throws Exception {

    FakeValuesService fakeValuesService = new FakeValuesService(
      new Locale("en-GB"), new RandomService());

    String email = fakeValuesService.bothify("????##@gmail.com");
    Matcher emailMatcher = Pattern.compile("\\w{4}\\d{2}@gmail.com").matcher(email);
 
    assertTrue(emailMatcher.find());
}

In this unit test, we create a new FakeValueService with a locale of en-GB and use the bothify method to generate a unique fake Gmail address.

It works by replacing ‘?’ with random letters and ‘#’ with random numbers. We can then check the output is correct with a simple Matcher check.

3.2. Regexify

Similarly, regexify generates a random sequence based on a chosen regex pattern.

In this snippet, we’ll use the FakeValueService to create a random sequence following a specified regex:

@Test
public void givenValidService_whenRegexifyCalled_checkPattern() throws Exception {

    FakeValuesService fakeValuesService = new FakeValuesService(
      new Locale("en-GB"), new RandomService());

    String alphaNumericString = fakeValuesService.regexify("[a-z1-9]{10}");
    Matcher alphaNumericMatcher = Pattern.compile("[a-z1-9]{10}").matcher(alphaNumericString);
 
    assertTrue(alphaNumericMatcher.find());
}

Our code creates a lower-case alphanumeric string of length 10. Our pattern checks the generated string against the regex.

4. JavaFaker’s Faker Class

The Faker class allows us to use JavaFaker’s fake data classes.

In this section, we’ll see how to instantiate a Faker object and use it to call some fake data:

Faker faker = new Faker();

String streetName = faker.address().streetName();
String number = faker.address().buildingNumber();
String city = faker.address().city();
String country = faker.address().country();

System.out.println(String.format("%s\n%s\n%s\n%s",
  number,
  streetName,
  city,
  country));

Above, we use the Faker Address object to generate a random address.

When we run this code, we’ll get an example of the output:

3188
Dayna Mountains
New Granvilleborough
Tonga

We can see that the data has no single geographical location since we didn’t specify a locale. To change this, we’ll learn to make the data more relevant to our location in the next section.

We could also use this faker object in a similar way to create data relating to many more objects such as:

• Business
• Beer
• Food
• PhoneNumber

You can find the full list here.

5. Introducing Locales

Here, we’ll introduce how to use locales to make the generated data more specific to a single location. We’ll introduce a Faker with a US locale, and a UK locale:

@Test
public void givenJavaFakersWithDifferentLocals_thenHeckZipCodesMatchRegex() {

    Faker ukFaker = new Faker(new Locale("en-GB"));
    Faker usFaker = new Faker(new Locale("en-US"));

    System.out.println(String.format("American zipcode: %s", usFaker.address().zipCode()));
    System.out.println(String.format("British postcode: %s", ukFaker.address().zipCode()));

    Pattern ukPattern = Pattern.compile(
      "([Gg][Ii][Rr] 0[Aa]{2})|((([A-Za-z][0-9]{1,2})|"
      + "(([A-Za-z][A-Ha-hJ-Yj-y][0-9]{1,2})|(([A-Za-z][0-9][A-Za-z])|([A-Za-z][A-Ha-hJ-Yj-y]" 
      + "[0-9]?[A-Za-z]))))\\s?[0-9][A-Za-z]{2})");
    Matcher ukMatcher = ukPattern.matcher(ukFaker.address().zipCode());

    assertTrue(ukMatcher.find());

    Matcher usMatcher = Pattern.compile("^\\d{5}(?:[-\\s]\\d{4})?$")
      .matcher(usFaker.address().zipCode());

    assertTrue(usMatcher.find());
}

Above, we see that the two Fakers with the locale match their regexes for the countries zip codes.

If the locale passed to the Faker does not exist, the Faker throws a LocaleDoesNotExistException.

We’ll test this with the following unit test:

@Test(expected = LocaleDoesNotExistException.class)
public void givenWrongLocale_whenFakerInitialised_testExceptionThrown() {
    Faker wrongLocaleFaker = new Faker(new Locale("en-seaWorld"));
}

6. Uniqueness

While JavaFaker seemingly generates data at Random, the uniqueness cannot be guaranteed.

JavaFaker supports seeding of its pseudo-random number generator (PRNG) in the form of a RandomService to provide the deterministic output of repeated method calls.

Simply put, pseudorandomness is a process that appears random but is not.

We can see how this works by creating two Fakers with the same seed:

@Test
public void givenJavaFakersWithSameSeed_whenNameCalled_CheckSameName() {

    Faker faker1 = new Faker(new Random(24));
    Faker faker2 = new Faker(new Random(24));

    assertEquals(faker1.name().firstName(), faker2.name().firstName());
}

The above code returns the same name from two different fakers.

7. Conclusion

In this tutorial, we have explored the JavaFaker library to generate real-looking fake data. We’ve also covered two useful classes the Faker class and the FakeValueService class.

We explored how we can use locales to generate location specific data.

Finally, we discussed how the data generated only seems random and the uniqueness of the data is not guaranteed.