Introduction

Approval Testing

Approval testing is a technique that allows you to compare the output of your code with a known good/previously approved output.

An approval test case will only succeed, if the actually received output is equal to the previously approved output.

If the received output is different from the approved output, the test will fail and leave it to human reviewer to approve received output or to fix the code.

Approval testing is especially useful for testing complex objects or large data sets, where it is impractical to write individual assertions for each property.

ApproveJ

ApproveJ is a Java implementation of approval testing with a builder-based fluent API, several built-in tools, and optional extension points.

To review the code, file issues or suggest changes, please visit the project’s GitHub page.

Getting Started

Requirements

In oder to use ApproveJ you need a JDK 21 or higher.

Dependencies

To use ApproveJ in your own project, you need to add it as a dependency.

Gradle
testImplementation 'org.approvej:core:1.0-RC1'
Gradle.kts
testImplementation("org.approvej:core:1.0-RC1")
Maven
<dependency>
  <groupId>org.approvej</groupId>
  <artifactId>core</artifactId>
  <version>1.0-RC1</version>
  <scope>test</scope>
</dependency>

Bill of Materials (BOM)

If you want to use more than one module in the same project, you can use ApproveJ’s bill of materials (BOM) and omit the explicit version for the other modules.

Gradle
implementation platform('org.approvej:bom:1.0-RC1')
implementation 'org.approvej:json-jackson'
Gradle.kts
implementation(platform("org.approvej:bom:1.0-RC1"))
implementation("org.approvej:json-jackson")
Maven
<project>
  <!--…-->
  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.approvej</groupId>
        <artifactId>bom</artifactId>
        <version>1.0-RC1</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>
  <!-- … -->
  <dependencies>
    <dependency>
      <groupId>org.approvej</groupId>
      <artifactId>json-jackson</artifactId>
    </dependency>
  </dependencies>
  <!-- … -->
</project>

Basics

The general entry point to start an approval is the static initializer approve of the ApprovalBuilder. It takes the object which you want to approve as an argument and returns a builder to configure the approval with a fluent API.

Approve Strings

If you have anything that returns an arbitrary string, you can simply build an approval like this

Java
String result = hello("World");

approve(result) (1)
    .byFile(); (2)
Kotlin
val result = hello("World")

approve(result) (1)
  .byFile() (2)
1 creates an ApprovalBuilder<String>
2 compares result to a previously approved value stored in a file next to the test and fails the test if the result differs

Executing such a test, will create two files next to the test code file named like <TestClass>-<testMethod>-received.txt and <TestClass>-<testMethod>-approved.txt.

The received file will always contain a string representation of the object you want to approve at the last execution.

The approved file will be empty at first. You can use a diff tool of your choice to compare the two files and merge values that you want to approve. If the received value equals the content of the approved file, the received file will be deleted automatically.

Approved file
Hello, World!

You can adjust various details of this process:

Approve POJOs

Of course, you might want to approve more complex objects than just strings.

For example a simple POJO like this

Person POJO
public record Person(String name, LocalDate birthDate) {}

By default, ApproveJ will simply call the object’s toString method to turn the object into a string just before approving it.

Java
Person person = createPerson("John Doe", LocalDate.of(1990, 1, 1));

approve(person) (1)
    .byFile();
Kotlin
val person = createPerson("John Doe", LocalDate.of(1990, 1, 1))

approve(person) (1)
  .byFile()
1 creates an ApprovalBuilder<Person> approve the person

Will approve the following value:

Approved file
Person[name=John Doe, birthDate=1990-01-01]

See Printing — customize how values are turned into Strings if need a more sophisticated way of printing.

Named Approvals — approve multiple values per test case

Optionally, you can assign a specific name for an approval. When you Approve by File the chosen name will be added to the filename to help identify the specific approval. It is also necessary to assign a name if there are multiple approvals per test case, as otherwise later approvals will overwrite earlier ones.

Java
Person jane = createPerson("Jane Doe", LocalDate.of(1990, 1, 1));
Person john = createPerson("John Doe", LocalDate.of(2012, 6, 2));

approve(jane).named("jane").byFile();
approve(john).named("john").byFile();
Kotlin
val jane = createPerson("Jane Doe", LocalDate.of(1990, 1, 1))
val john = createPerson("John Doe", LocalDate.of(2012, 6, 2))

approve(jane).named("jane").byFile()
approve(john).named("john").byFile()

This test generates two sets of files

  1. <TestClass>-<testMethod>-jane-<received/approved>.txt

  2. <TestClass>-<testMethod>-john-<received/approved>.txt

Printing — customize how values are turned into Strings

While some toString implementations already are quite good, they typically return a one-liner. This is fine as long as you only have a few properties. However, if you have a lot of properties, it is much easier to read the result if it is formatted nicely.

In order to change the way objects are being transformed to strings, you can use the ApprovalBuilder’s `printedBy method with a Printer/Function<T, String>, or its printedAs method with a PrintFormat.

In addition to the printing method, the Printer, the PrinterFormat also provides a filename extension, that will be used if the value is written to a file (see Approve by File).

Generic Multi Line String Print Format

ApproveJ provides a generic MultiLineStringPrintFormat that will print the object with each of its properties on a new line to make comparing the result easier. You can use this format by calling the printedAs method on the builder.

Java
Person person = createPerson("John Doe", LocalDate.of(1990, 1, 1));

approve(person)
    .printedAs(multiLineString()) (1)
    .byFile();
Kotlin
val person = createPerson("John Doe", LocalDate.of(1990, 1, 1))

approve(person)
  .printedAs(multiLineString()) (1)
  .byFile()
1 applies the MultiLineStringPrinter and returns a new ApprovalBuilder<String>

Now the approved file will look like this

Approved file
Person [
  name=John Doe,
  birthDate=1990-01-01
]

Custom Printer Function

You can provide a custom Function<T, String> to the builder’s printedBy method.

Java
Person person = createPerson("John Doe", LocalDate.of(1990, 1, 1));

approve(person)
    .printedBy(it -> String.format("%s, born %s", it.name(), it.birthDate())) (1)
    .byFile();
Kotlin
val person = createPerson("John Doe", LocalDate.of(1990, 1, 1))

approve(person)
  .printedBy { "%s, born %s".format(it.name, it.birthDate) } (1)
  .byFile()
1 applies the given Function and returns a new ApprovalBuilder<String>

So the content of the approved file will look like this

Approved file
John Doe, born 1990-01-01

Custom Printer Format

For more complex cases, you can implement your own PrinterFormat.

This will allow you to also override the filenameExtension method. If you use a FileApprover (see Approve by File), it will be used to determine the files' filename extension. This is useful, if your Printer creates a certain format (e.g. JSON, XML, YAML, …).

E.g. the following format will print a Person as a YAML string.

Java
public static class PersonYamlPrintFormat implements PrintFormat<Person> {
  @Override
  public Printer<Person> printer() {
    return (Person person) ->
        """
        person:
          name: "%s"
          birthDate: "%s"
        """
            .formatted(person.name(), person.birthDate());
  }

  @Override
  public String filenameExtension() {
    return "yaml";
  }
}
Kotlin
class PersonYamlPrinter : PrintFormat<Person> {
  override fun printer() =
    Printer<Person> { person ->
      """
    person:
      name: "${person.name}"
      birthDate: "${person.birthDate}"
    """
        .trimIndent()
    }

  override fun filenameExtension() = "yaml"
}

The resulting file will look like this

Approved file
person:
  name: "John Doe"
  birthDate: "1990-01-01"

Scrubbing — make random parts static

Sometimes you might not be able to control the exact output of the object you want to approve. For example, if the result object contains a timestamp or a generated ID, you might want to ignore these for the approval.

You can do this by using the scrubbedOf method of the ApprovalBuilder and provide a Scrubber/UnaryOperator<T> implementation.

For instance, in the following BlogPost POJO there are two generated fields:

Java
class BlogPost {
  private final UUID id;
  private final String title;
  private final String content;
  private final Instant published;

  public BlogPost(String title, String content) {
    this.id = UUID.randomUUID(); (1)
    this.title = title;
    this.content = content;
    this.published = Instant.now(); (2)
  }

  public String title() {
    return title;
  }

  public String content() {
    return content;
  }

  public Instant published() {
    return published;
  }

  public UUID id() {
    return id;
  }

  @Override
  public String toString() {
    return "BlogPost[title=%s, content=%s, published=%s, id=%s]"
        .formatted(title, content, published, id);
  }
}
1 the id is a UUID that’s being generated randomly, and
2 the published is a LocalDateTime set to now.

In the flowing example, the two dynamic properties are scrubbed with the built-in Scrubbers for uuids and instants.

Java
BlogPost blogPost =
    createBlogPost("Latest News", "Lorem ipsum dolor sit amet, consectetur adipiscing elit.");

approve(blogPost)
    .printedAs(multiLineString())
    .scrubbedOf(dateTimeFormat("yyyy-MM-dd'T'HH:mm:ss.SSSX")) (1)
    .scrubbedOf(uuids()) (2)
    .byFile(); (3)
Kotlin
val blogPost =
  createBlogPost("Latest News", "Lorem ipsum dolor sit amet, consectetur adipiscing elit.")

approve(blogPost)
  .printedAs(multiLineString())
  .scrubbedOf(dateTimeFormat("yyyy-MM-dd'T'HH:mm:ss.SSSX")) (1)
  .scrubbedOf(uuids()) (2)
  .byFile()
1 replaces the published date with a numbered placeholder
2 replaces the id UUID with a numbered placeholder
3 so that the approved result looks like this
Approved file
BlogPost [
  id=[uuid 1],
  title=Latest News,
  content=Lorem ipsum dolor sit amet, consectetur adipiscing elit.,
  published=[datetime 1]
]

Generally a built-in Scrubber uses a replacement function that replaces all matches with a numbered placeholder in the form of [<label> <counter>] (e.g. [uuid 1], [date 2], …). Note that two matches of the same (e.g. the same UUID in two places) will be replaced with the same placeholder, so you can still see that two scrubbed values were equal.

Custom Scrubber

The RegexScrubber already allows for a lot of special custom cases. In case this isn’t enough, you can also provide a custom Scrubber<T>/UnaryOperator<T> implementation to the builder’s scrubbedOf method.

Java
Contact contact = createContact("Jane Doe", "jane@approvej.org", "+1 123 456 7890");
approve(contact)
    .scrubbedOf(it -> new Contact(-1, it.name(), it.email(), it.phoneNumber())) (1)
    .printedAs(multiLineString())
    .byFile();
Kotlin
val contact = createContact("Jane Doe", "jane@approvej.org", "+1 123 456 7890")

approve(contact)
  .scrubbedOf { Contact(-1, it.name, it.email, it.phoneNumber) } (1)
  .printedAs(multiLineString())
  .byFile()
1 this custom Scrubber specifically replaces the number property of the Contact with a constant
Approved file
Contact [
  number=-1,
  name=Jane Doe,
  email=jane@approvej.org,
  phoneNumber=+1 123 456 7890
]

Note that this Scrubber is a Scrubber<Contact> and not a Scrubber<String>. Hence, it is necessary to apply it before the Printer is applied.

In case you want to reuse the Scrubber, you can also define in a separate class implementing the Scrubber<T> interface.

Built-In Scrubbers & Replacements

All built-in Scrubber implementations are available via the Scrubbers utility class.

Note that RegexScrubber implementations also allow to change the Replacement function. Built-in implementation can be found in the Replacements utility class.

Approving — adjust the verification

You conclude the ApprovalBuilder by specifying by which Approver the received value should be approved.

Approve by Value

The ApprovalBuilder.byValue() method will use an InplaceApprover to approve the received value by comparison with a directly provided previously approved value. That way, the approved value is plainly visible in the test code. However, this might not be practical for large objects. It also does not allow to use a diff tool to compare the result with the previously approved value.

Java
Person person = createPerson("John Doe", LocalDate.of(1990, 1, 1));

approve(person).byValue("Person[name=John Doe, birthDate=1990-01-01]");
Kotlin
val person = createPerson("John Doe", LocalDate.of(1990, 1, 1))

approve(person).byValue("Person[name=John Doe, birthDate=1990-01-01]")

Approve by File

The ApprovalBuilder.byFile() method will use a FileApprover to approve the received value by comparison a previously approved value stored in a file. It is used in most of the examples above.

If no approved file exists, it will be created as an empty approved file. The received value will be written to another received file.

If there are approved files with the correct base name, but a different filename extension, these will be automatically deleted. The most recently modified one is renamed with the correct filename extension, if no file of that name exists yet.

If the approved file exists, it will be compared with the received value. If they are equal, the test will pass. Any existing received file will be deleted automatically in that case.

If the files are not equal, the test will fail. The received value will be persisted in a received file. Any existing received value will be overwritten by this.

You can use a diff tool of your choice to compare the two files and merge values that you want to approve.

Next to Test

By default, the FileApprover will put the received and approved files next to the test class and name them like the test case method.

You can make this explicit by using the PathProviderBuilder.nextToTest() method.

Java
Person person = createPerson("John Doe", LocalDate.of(1990, 1, 1));

approve(person).byFile(nextToTest()); (1)
Kotlin
val person = createPerson("John Doe", LocalDate.of(1990, 1, 1))

approve(person).byFile(nextToTest()) (1)
1 defines the PathProvider explicitly, same as just calling byFile()
File structure
.
└── 📁src/test/java/…
    ├── 📄 <TestClass>.java
    ├── 📄 <TestClass>-<testMethod>-approved.txt
    └── 📄 <TestClass>-<testMethod>-received.txt
Custom Filename Extension

The PathProviderBuilder.filenameExtension method gives you the opportunity to use a different file extension for the approved and received files.

NOTE

most of the time you probably want to do this because you’re using a special printer that creates a specific format (e.g. JSON, XML, YAML, …). In that case, you might want to provide a Custom Printer Format and override the filenameExtension method of the Printer instead of changing the filename extension here.

Java
Person person = createPerson("John Doe", LocalDate.of(1990, 1, 1));

approve(person)
    .printedBy(
        it ->
            """
            person:
              name: "%s"
              birthDate: "%s"
            """
                .formatted(it.name(), it.birthDate())) (1)
    .byFile(nextToTest().filenameExtension("yml"));
Kotlin
val person = createPerson("John Doe", LocalDate.of(1990, 1, 1))

approve(person)
  .printedBy {
    """
    person:
      name: "${it.name}"
      birthDate: "${it.birthDate}"
    """
      .trimIndent()
  } (1)
  .byFile(nextToTest().filenameExtension("yml")) (2)
1 this printer will create a YAML version of the object
2 so it makes sense to change the filename extension, so your IDE will apply appropriate syntax highlighting
File structure with custom filename extension
.
└── 📁src/test/java/…
    ├── 📄 <TestClass>.java
    ├── 📄 <TestClass>-<testMethod>-approved.<filenameExtension>
    └── 📄 <TestClass>-<testMethod>-received.<filenameExtension>
In a Subdirectory

If you have test classes with a lot of approval tests, there a quite a lot of files created next to the test class. In that case, you can use the PathProviderBuilder.nextToTestInSubdirectory to put all the files in a subdirectory named after the test class.

Java
Person person = createPerson("John Doe", LocalDate.of(1990, 1, 1));

approve(person).printedAs(new PersonYamlPrintFormat()).byFile(nextToTestInSubdirectory());
Kotlin
val person = createPerson("John Doe", LocalDate.of(1990, 1, 1))

approve(person).printedAs(PersonYamlPrinter()).byFile(nextToTestInSubdirectory())
File structure with subdirectory
.
└── 📁src/test/java/…
    ├── 📁 <TestClass>
    │   ├── 📄 <testMethod>-approved.txt
    │   └── 📄 <testMethod>-received.txt
    └── 📄 <TestClass>.java
Given Path

Alternatively, you can simply specify the path of the approved file. If the given approved file path contains the word approved just before the filename extension, it will be replaced with received in the to determine the received file path. Otherwise, the word received will be added at the end of the filename.

For example

  • src/test/resources/BasicsDocTest-approve_file_approved_path-approved.yaml → src/test/resources/BasicsDocTest-approve_file_approved_path-received.yaml

  • src/test/resources/BasicsDocTest-approve_file_approved_path.yaml → src/test/resources/BasicsDocTest-approve_file_approved_path-received.yaml.

Java
Person person = createPerson("John Doe", LocalDate.of(1990, 1, 1));

approve(person)
    .printedAs(new PersonYamlPrintFormat())
    .byFile("src/test/resources/BasicExamples-approve file approved path.yaml"); (1)
Kotlin
val person = createPerson("John Doe", LocalDate.of(1990, 1, 1))

approve(person)
  .printedAs(PersonYamlPrinter())
  .byFile("src/test/resources/BasicExamples-approve file approved path.yaml") (1)
1 this will expect the approved file at this path, the received file will be created next to it at src/test/resources/BasicsDocTest-approve_file_approved_path-reveived.yaml
File structure with given path
.
└── 📁src/test/java/…
│   └── 📄 <TestClass>.java
└── 📁src/test/resources
    ├── 📄 src/test/resources/BasicExamples-approve_file_approved_path.yaml
    └── 📄 src/test/resources/BasicExamples-approve_file_approved_path-received.yaml
Custom PathProvider/PathProviderBuilder

You can also define your own PathProvider and pass it to the byFile method.

Or you can create a method that returns a PathProviderBuilder and pass it to the byFile method. That way the filename extension of the used Printer is set just before approval.

In that case, you might want to take advantage of the StackTraceTestFinderUtil class to find the test source path or the current test method based on the current stack trace.

Reviewing — check differences

If the received value differs from the previously approved, ApproveJ will by default simply fail the test. You then need to review the differences and decide if these are to be approved or actually were not intended. This can simply be done by find the failing test and compare the received and approved files within you IDE or with an external tool. To help you with that process, ApproveJ allows to configure a script that will open such a tool automatically (see Configuration).

Blocking/Non-Blocking Review

Some FileReviewers are blocking. They trigger the diff/merge tool and wait for you to close it again. This gives you the opportunity to merge the content of the two files before the test finishes, so the test does not fail due to your given approval.

Other implementations are non-blocking. These simply display the differences between the two files, but will fail the test immediately. So, after you merged the files or fixed the code, you need to run the test again.

Choose Reviewer in Test

You can choose the FileReviewer to use in the test code by calling the reviewedBy method on the ApprovalBuilder.

Java
Person person = createPerson("John Doe", LocalDate.of(1990, 1, 1));

approve(person)
    .printedAs(new PersonYamlPrintFormat())
    .reviewedBy("idea diff {receivedFile} {approvedFile}") (1)
    .byFile(); (2)
Kotlin
val person = createPerson("John Doe", LocalDate.of(1990, 1, 1))

approve(person)
  .printedAs(PersonYamlPrinter())
  .reviewedBy("meld \"{receivedFile}\" \"{approvedFile}\"") (1)
  .byFile() (2)
1 sets the given script to be executed to support the review
2 executes the review script if the received value differs from the approved value

Configuration

Optionally you can configure the default behaviors of ApproveJ by putting an approvej.properties file into your home directory at ~/.config/approvej/approvej.properties or into the resource folder of your test suite (e.g. src/test/resources/approvej.properties).

The home directory properties will be overridden by those in the resource directory.

Example approvej.properties
defaultPrintFormat = org.approvej.print.SingleLineStringPrintFormat
defaultFileReviewerScript = idea diff --wait "{receivedFile}" "{approvedFile}"

Supported properties are:

defaultPrintFormat

the default print format class if none is specified via the printedAs method (see Printing — customize how values are turned into Strings)

defaultFileReviewerScript

the script that should be executed to support a review of the differences between the previously approved and the actually received value (see Reviewing — check differences)

NOTE

The former property defaultPrinter is deprecated and using it will cause an exception!

JSON with Jackson

The json-jackson module provides several JSON-related features implemented with Jackson.

To use it, you need to add it as a dependency to your project.

Gradle
implementation 'org.approvej:json-jackson:1.0-RC1'
Gradle.kts
implementation("org.approvej:json-jackson:1.0-RC1")
Maven
<project>
  <!-- … -->
  <dependencies>
    <dependency>
      <groupId>org.approvej</groupId>
      <artifactId>json-jackson</artifactId>
      <version>1.0-RC1</version>
    </dependency>
  </dependencies>
  <!-- … -->
</project>

Scrub JSON

The JsonPointerScrubber can be used to scrub a JSON node identified by a JsonPointer.

Compared to generic Scrubber<String> implementations this is particularly useful when there are several values matching the same pattern, but only one of them needs to be scrubbed. For instance, if you have a JSON containing two UUIDs, one that was generated by the code (and hence needs to be scrubbed) and one that is a reference to another resource and should not be scrubbed.

Java
String createdBlogPostJson =
    createTaggedBlogPost(
        "Latest News",
        "Lorem ipsum dolor sit amet, consectetur adipiscing elit.",
        List.of(NEWS, ENTERTAINMENT));

approve(jsonMapper.readTree(createdBlogPostJson))
    .scrubbedOf(jsonPointer("/id").replacement("[scrubbed id]")) (1)
    .scrubbedOf(jsonPointer("/published").replacement("[scrubbed published]")) (2)
    .by(file(nextToTest().filenameExtension("json"))); (3)
Kotlin
val createdBlogPostJson =
  createTaggedBlogPost(
    "Latest News",
    "Lorem ipsum dolor sit amet, consectetur adipiscing elit.",
    listOf(NEWS, ENTERTAINMENT),
  )

approve(jsonMapper.readTree(createdBlogPostJson))
  .scrubbedOf(jsonPointer("/id").replacement("[scrubbed id]")) (1)
  .scrubbedOf(jsonPointer("/published").replacement("[scrubbed published]")) (2)
  .by(file(nextToTest().filenameExtension("json"))) (3)
1 scrubs the dynamically assigned id node on the root level of the JSON and replaces it with "[scrubbed id]"
2 scrubs the published timestamp node on the root level of the JSON and replaces it with "[scrubbed published]"
3 stores the received data at a file next to the test with the file extension .json
Approved file
{"id":"[scrubbed id]","title":"Latest News","content":"Lorem ipsum dolor sit amet, consectetur adipiscing elit.","tagIds":["00000000-0000-0000-0000-000000000001","00000000-0000-0000-0000-000000000002"],"published":"[scrubbed published]"}

Pretty Print JSON

In the example above, the JSON persisted in a one-liner. Even for the simple example, this is not very readable, let alone easily comparable to a slightly different JSON. To improve this, you can use the JsonPrintFormat.

Java
String createdBlogPostJson =
    createTaggedBlogPost(
        "Latest News",
        "Lorem ipsum dolor sit amet, consectetur adipiscing elit.",
        List.of(NEWS, ENTERTAINMENT));

approve(jsonMapper.readTree(createdBlogPostJson))
    .scrubbedOf(jsonPointer("/id").replacement("[scrubbed id]"))
    .scrubbedOf(jsonPointer("/published").replacement("[scrubbed published]"))
    .printedAs(json()) (1)
    .byFile();
Kotlin
val createdBlogPostJson =
  createTaggedBlogPost(
    "Latest News",
    "Lorem ipsum dolor sit amet, consectetur adipiscing elit.",
    listOf(NEWS, ENTERTAINMENT),
  )

approve(jsonMapper.readTree(createdBlogPostJson))
  .scrubbedOf(jsonPointer("/id").replacement("[scrubbed id]"))
  .scrubbedOf(jsonPointer("/published").replacement("[scrubbed published]"))
  .printedAs(json()) (1)
  .byFile()
1 applies the JsonPrintFormat to convert the JsonNode object to a string

Now the approved file is much more readable.

Approved file
{
  "id" : "[scrubbed id]",
  "title" : "Latest News",
  "content" : "Lorem ipsum dolor sit amet, consectetur adipiscing elit.",
  "tagIds" : [ "00000000-0000-0000-0000-000000000001", "00000000-0000-0000-0000-000000000002" ],
  "published" : "[scrubbed published]"
}

Pretty Print JSON Strings

It is not necessary to parse the JSON string before printing it. If the value is a string, JsonPrintFormat automatically pretty prints it. The only downside is, that you can not use JSON-specific scrubbers.

Java
String createdBlogPostJson =
    createTaggedBlogPost(
        "Latest News",
        "Lorem ipsum dolor sit amet, consectetur adipiscing elit.",
        List.of(NEWS, ENTERTAINMENT));

approve(createdBlogPostJson)
    .scrubbedOf(uuids())
    .scrubbedOf(dateTimeFormat("yyyy-MM-dd'T'HH:mm:ss.SSSX"))
    .printedAs(json()) (1)
    .byFile();
Kotlin
val createdBlogPostJson =
  createTaggedBlogPost(
    "Latest News",
    "Lorem ipsum dolor sit amet, consectetur adipiscing elit.",
    listOf(NEWS, ENTERTAINMENT),
  )

approve(createdBlogPostJson)
  .scrubbedOf(uuids())
  .scrubbedOf(dateTimeFormat("yyyy-MM-dd'T'HH:mm:ss.SSSX"))
  .printedAs(json()) (1)
  .byFile()
1 applies the JsonPrintFormat to pretty print the given JSON string
Approved file
{
  "id" : "[uuid 1]",
  "title" : "Latest News",
  "content" : "Lorem ipsum dolor sit amet, consectetur adipiscing elit.",
  "tagIds" : [ "[uuid 2]", "[uuid 3]" ],
  "published" : "[datetime 1]"
}

Note that the applied scrubbers also replaced the tag IDs.

YAML with Jackson

The yaml-jackson module provides several YAML-related features implemented with Jackson.

To use it, you need to add it as a dependency to your project.

Gradle
implementation 'org.approvej:yaml-jackson:1.0-RC1'
Gradle.kts
implementation("org.approvej:yaml-jackson:1.0-RC1")
Maven
<project>
  <!-- … -->
  <dependencies>
    <dependency>
      <groupId>org.approvej</groupId>
      <artifactId>yaml-jackson</artifactId>
      <version>1.0-RC1</version>
    </dependency>
  </dependencies>
  <!-- … -->
</project>

Print as YAML

The YamlPrintFormat allows to print any object in YAML format.

Java
Person person = createPerson("John Doe", LocalDate.of(1990, 1, 1));

approve(person)
    .printedAs(yaml()) (1)
    .byFile();
Kotlin
val person = createPerson("John Doe", LocalDate.of(1990, 1, 1))

approve(person)
  .printedAs(yaml()) (1)
  .byFile()
1 applies the YamlPrintFormat to convert the Person object to a string

Creates the following approved file:

Approved file
---
name: "John Doe"
birthDate: "1990-01-01"