Object MotherとTest Data Builder、Test Data BuilderとInstancioでテストデータ作成

これは、なにをしたくて書いたもの？

テストを書く時に、テストデータの扱いには頭を悩ませます。

ここでいう「テストデータ」とは、データストア、主にデータベースを対象にしたテストで使うデータのことです。

どう作ったらいいのか、どうメンテナンスしていったらいいのかだったり悩みは尽きないのですが、
テストデータに関するパターンがあるようなのでメモしておきます。

テストデータの悩み

ひとまず、対象の言語はJavaとしましょう。

データベースを使ったテストについて調べると、いろいろ出てきます。

• データベースアクセスはモックにする
• テスト内でデータをセットアップするコードを書く
• DbUnitなどのテスティングフレームワークを使う

とまあ、簡単にテストができる仕組みだったり方法はすぐに見つかります。こういった中から方針に合ったものを
選ぶ、という感じですね。

ただ、実際にやってみると悩むのはテストデータの扱いだったりします。具体的にはこういう悩みがあるかなと。

あくまで主観です。

テストデータを作るのが大変

まず、テストデータを作るのが大変です。

世の中のサンプルコードだとさらっと済ましていることが多いですが、実際のアプリケーションを作る時には
多くのテーブルのデータが必要になることが多いでしょう。

外部キーを使っていることも多いと思いますので、そうなると末端の機能ほど関連するテーブルが増えていき
芋づる式に作らないといけないデータが多くなります。

こうなるとまずどのようなデータを用意する必要があるのか、考えるのが大変です。

そしてテストケースごとに少しだけ内容が違うデータができたりします。

テストコードの中でテストデータのセットアップをすることも多いと思いますが、その時にテストコード
そのものよりもテストデータをセットアップするコードの方が長くなったりします。

ではSQLやYAMLなどで用意すればいいかというと、それは書く場所が違うだけという気がしますね。

手段の話でいくと、このブログではDatabase Riderを使ったりしました。

Database Riderを試してみる - CLOVER🍀

Spring Test × Database Riderで、データを作成する時にテーブル間の依存関係を記録する - CLOVER🍀

テストデータを共通化すると変更時の影響が大きいが、共通化しないと似たようなものがたくさん増えていく

テストデータを作るのが大変だと、その手間を減らすために共通化したくなるものです。
テストデータをコードで作っている場合は特にそうかなと思います。

ただ、共通化して作っていると変更時の影響範囲がとても大きくなります。

でも個々のテストで同じものを作っていると、仕様が変わったりして変更する時にやっぱり修正しないと
いけない対象が個々に発生します。

テストデータが読みにくい

テストデータは意外と読みにくい気がします。たとえコードで書かれていても。

テストコードを変更する時に、その前提となるテストデータや期待値となるデータが読み解けず苦労することが
多い印象があるのですが、どうでしょうか。

アプリケーションに書かれる処理と違って、あまり意志（？）が見えにくかったり、頭の中で1度テーブルでの
持ち方に変換して考えようとするので思考のコストが大きいからな気もするのですが。

複合

ここまでがテストデータに対する悩みなのですが、この悩みそれぞれが絡み合って話が難しくなっている気が
するんですよね。

テストデータを作るのが大変、しかも後で見返しても読みにくい（読めない）。共通化しているので
変更するのも怖い。ならコピーしてちょっとだけ違うものを作って…みたいなことをするような気がします。

これ、みなさんどうやって乗り越えていってるんでしょうね。

パターン

それはそうと、テストデータを作るパターンがあるようなのでちょっとメモしておきましょう。

• Object Mother
• Test Data Builder

Object Mother

Object MotherはMartin Fowlerが解説しているパターンで、Thoughtworksのプロジェクトで考案されたものです。
テストで使用するデータ（オブジェクト）を作るためのパターンです。

Object Mother

Object Mother

テストで組み立てる以下のようなコードを

Invoice invoice = new Invoice(
    new Recipient("Sherlock Holmes",
        new Address("221b Baker Street", 
                    "London", 
                    new PostCode("NW1", "3RX"))),
    new InvoiceLines(
        new InvoiceLine("Deerstalker Hat", 
            new PoundsShillingsPence(0, 3, 10)),
        new InvoiceLine("Tweed Cape", 
            new PoundsShillingsPence(0, 4, 12))));

ファクトリーメソッドにまとめます。このファクトリーメソッドが定義されたクラスがObject Motherです。

Invoice invoice = TestInvoices.newDeerstalkerAndCapeInvoice();

Object Motherを使うことで、テストデータ（オブジェクト）を生成するコードをテストコードから分離、
ファクトリーメソッドに適切なメソッドをつけることで可読性も向上します。テスト間での再利用も可能です。

なのですが、Object Motherはテストデータのバリエーションに対応できません。少し異なるテストデータが
必要になると、Object Motherに別のファクトリーメソッドが追加されます。

Invoice invoice1 = TestInvoices.newDeerstalkerAndCapeAndSwordstickInvoice();
Invoice invoice2 = TestInvoices.newDeerstalkerAndBootsInvoice();

こちらのページには、Object Motherはアンチパターンなのでは？と書かれています。

Object Mother

このような結果、Object Motherがすべてのものを飲み込んだGod Class（God Object Mother）に
なりやすいからです。結果としてメンテナンスが困難になっていきます。

Object Motherでは固定のデータになってしまうため、Builderパターンを適用した方がよいのではないか
ということで出てきたのがTest Data Builderです。

Test Data Builder

Test Data BuilderはNat Pryceが「実践テスト駆動開発」の中で、Object Motherの弱点を述べたうえで
紹介しているパターンです。

Mistaeks I Hav Made: Test Data Builders: an alternative to the Object Mother pattern

Test Data Builder

実践テスト駆動開発 テストに導かれてオブジェクト指向ソフトウェアを育てる（和智 右桂 和智 右桂 髙木 正弘 髙木 正弘 Steve Freeman Nat Pryce）｜翔泳社の本

ちなみに、Object Motherの紹介で書いたサンプルコードはTest Data Builderのエントリーから持ってきたものです。
実践テスト駆動開発でもよく似たコードが書かれています。

以下はTest Data Builderの例です。

public class InvoiceBuilder {
    Recipient recipient = new RecipientBuilder().build();
    InvoiceLines lines = new InvoiceLines(new InvoiceLineBuilder().build());
    PoundsShillingsPence discount = PoundsShillingsPence.ZERO;

    public InvoiceBuilder withRecipient(Recipient recipient) {
        this.recipient = recipient;
        return this;
    }

    public InvoiceBuilder withInvoiceLines(InvoiceLines lines) {
        this.lines = lines;
        return this;
    }

    public InvoiceBuilder withDiscount(PoundsShillingsPence discount) {
        this.discount = discount;
        return this;
    }

    public Invoice build() {
        return new Invoice(recipient, lines, discount);
    }
}

ポイントは以下になります。

• 依存するインスタンスをフィールドに保持している
• buildメソッドで依存するインスタンスを含めて、対象のインスタンスを構築する
• インスタンスは指定がなければデフォルト値で初期化する
• Builderのインスタンスを返すメソッドを持ち、内部で保持しているインスタンスをカスタマイズできる

デフォルト値でよければ、以下の呼び出しで対象のインスタンスが手に入ります。

Invoice anInvoice = new InvoiceBuilder().build();

Builderを使うことで、インスタンスの値をカスタマイズできます。

Invoice invoiceWithNoPostcode = new InvoiceBuilder()
    .withRecipient(new RecipientBuilder()
        .withAddress(new AddressBuilder()
            .withNoPostcode()
            .build())
        .build())
    .build();


new AddressBuilder()
    .withName("Sherlock Holmes")
    .withStreet("221b Baker Street")
    .withCity("London")
    .withPostCode("NW1", "3RX")
    .build();

またBuilderに別のBuilderを渡してインスタンスをカスタマイズできるようにしてもよいでしょう。

で、どうなの？

で、Test Data Builderを使えば自分が思っている悩みポイントはすっきり解決するかというと、意外とそうでも
ありません。

このあたりが理由ですね。

• Builderを作るのが大変
• Builderでカスタマイズされたテストデータを読み解くのが大変
• Builderで作られたGod Object Motherができあがる可能性が高い

まあ、うまい方法はないという気はします。

そもそも

• Object Motherの記事は2006年のもの
• Test Data Builderの記事は2007年のもの
• データベースを使ったテスティングフレームワークがなかなか流行らない

という感じですからね。

Database RiderやAseertJ-DBの更新が滞っているのを見ると、なかなか厳しいんだろうなと。

割とJava寄りの話にしていますが、他の言語ってDbUnitのような立ち位置のライブラリーってあんまりない気が
します。

Test Data Builder＋通常のアサーション、というのが落ち着き先なのかもしれません。

最後に軽くInstancioを使ってTest Data Builderを試してみましょう。Instancioはテストデータをランダムに
生成するライブラリーです。

テストデータをランダムに生成してインスタンスに設定するライブラリー、Instancioを試す - CLOVER🍀

環境

今回の環境はこちら。

$ java --version
openjdk 25.0.2 2026-01-20
OpenJDK Runtime Environment (build 25.0.2+10-Ubuntu-124.04)
OpenJDK 64-Bit Server VM (build 25.0.2+10-Ubuntu-124.04, mixed mode, sharing)


$ mvn --version
Apache Maven 3.9.12 (848fbb4bf2d427b72bdb2471c22fced7ebd9a7a1)
Maven home: $HOME/.sdkman/candidates/maven/current
Java version: 25.0.2, vendor: Ubuntu, runtime: /usr/lib/jvm/java-25-openjdk-amd64
Default locale: ja_JP, platform encoding: UTF-8
OS name: "linux", version: "6.8.0-100-generic", arch: "amd64", family: "unix"

データベースにはMySQLを使います。

 MySQL  localhost:3306 ssl  practice  SQL > select version();
+-----------+
| version() |
+-----------+
| 8.4.8     |
+-----------+
1 row in set (0.0006 sec)

MySQLは172.17.0.2で動作しているものとします。

準備

Maven依存関係などはこちら。

    <properties>
        <maven.compiler.release>25</maven.compiler.release>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.seasar.doma</groupId>
            <artifactId>doma-core</artifactId>
            <version>3.11.1</version>
        </dependency>
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <version>9.6.0</version>
            <scope>runtime</scope>
        </dependency>

        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>6.0.2</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.assertj</groupId>
            <artifactId>assertj-core</artifactId>
            <version>3.27.7</version>
        </dependency>

        <dependency>
            <groupId>org.instancio</groupId>
            <artifactId>instancio-core</artifactId>
            <version>5.5.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.14.1</version>
                <configuration>
                    <annotationProcessorPaths>
                        <path>
                            <groupId>org.seasar.doma</groupId>
                            <artifactId>doma-processor</artifactId>
                            <version>3.11.1</version>
                        </path>
                    </annotationProcessorPaths>
                </configuration>
            </plugin>
        </plugins>
    </build>

データベースアクセスライブラリーとしてはDomaを使います。

お題

今回のお題は、ブログとその著者にしましょう。

こういうテーブルにします。

create table if not exists author(
  id varchar(36),
  first_name varchar(10),
  last_name varchar(10),
  age integer,
  primary key(id)
);

create table if not exists author(
  id varchar(36),
  first_name varchar(10),
  last_name varchar(10),
  age integer,
  primary key(id)
);

ソースコードを作成する

このお題でソースコードを作成しておきます。

Domaのエンティティークラス。

src/main/java/org/littlewings/testdatabuilder/entity/Author.java

package org.littlewings.testdatabuilder.entity;

import org.seasar.doma.Entity;
import org.seasar.doma.Id;

@Entity
public record Author(
        @Id
        String id,
        String firstName,
        String lastName,
        Integer age
) {
}

src/main/java/org/littlewings/testdatabuilder/entity/Post.java

package org.littlewings.testdatabuilder.entity;

import java.time.LocalDate;
import org.seasar.doma.Entity;
import org.seasar.doma.Id;

@Entity
public record Post(
        @Id
        String id,
        String title,
        String url,
        LocalDate date,
        String authorId
) {
}

Dao。

src/main/java/org/littlewings/testdatabuilder/dao/AuthorDao.java

package org.littlewings.testdatabuilder.dao;

import java.util.List;
import org.littlewings.testdatabuilder.entity.Author;
import org.seasar.doma.Dao;
import org.seasar.doma.Delete;
import org.seasar.doma.Insert;
import org.seasar.doma.Script;
import org.seasar.doma.Select;
import org.seasar.doma.Sql;
import org.seasar.doma.jdbc.Result;

@Dao
public interface AuthorDao {
    @Sql("""
            create table if not exists author(
              id varchar(36),
              first_name varchar(10),
              last_name varchar(10),
              age integer,
              primary key(id)
            )
            """)
    @Script
    void createTableIfExistsRecreate();

    @Sql("delete from author")
    @Delete
    int deleteAll();

    @Insert
    Result<Author> insert(Author author);

    @Sql("select /*%expand*/* from author where id = /* id */'dummy'")
    @Select
    Author selectById(String id);

    @Sql("select /*%expand*/* from author order by age desc")
    @Select
    List<Author> selectAllOrderByAgeDesc();
}

src/main/java/org/littlewings/testdatabuilder/dao/PostDao.java

package org.littlewings.testdatabuilder.dao;

import java.util.List;
import org.littlewings.testdatabuilder.entity.Post;
import org.seasar.doma.Dao;
import org.seasar.doma.Delete;
import org.seasar.doma.In;
import org.seasar.doma.Insert;
import org.seasar.doma.Script;
import org.seasar.doma.Select;
import org.seasar.doma.Sql;
import org.seasar.doma.jdbc.Result;

@Dao
public interface PostDao {
    @Sql("""
            create table if not exists post(
              id varchar(36),
              title varchar(200),
              url text,
              date date,
              author_id varchar(36),
              primary key(id),
              foreign key(author_id) references author(id)
            )
            """)
    @Script
    void createTableIfExistsRecreate();

    @Sql("delete from post")
    @Delete
    int deleteAll();

    @Insert
    Result<Post> insert(Post post);

    @Sql("select /*%expand*/* from post order by date desc")
    @Select
    List<Post> selectAllOrderByDateDesc();
}

Domaの設定クラス。

src/main/java/org/littlewings/testdatabuilder/DomaConfig.java

package org.littlewings.testdatabuilder;

import javax.sql.DataSource;

import org.seasar.doma.jdbc.Config;
import org.seasar.doma.jdbc.Naming;
import org.seasar.doma.jdbc.dialect.Dialect;
import org.seasar.doma.jdbc.dialect.MysqlDialect;
import org.seasar.doma.jdbc.tx.LocalTransactionDataSource;
import org.seasar.doma.jdbc.tx.LocalTransactionManager;
import org.seasar.doma.jdbc.tx.TransactionManager;

public class DomaConfig implements Config {
    private static final DomaConfig INSTANCE = new DomaConfig();

    private Dialect dialect;
    private LocalTransactionDataSource dataSource;
    private TransactionManager transactionManager;

    private DomaConfig() {
        dialect = new MysqlDialect(MysqlDialect.MySqlVersion.V8);
        dataSource = new LocalTransactionDataSource(
                "jdbc:mysql://172.17.0.2:3306/practice?characterEncoding=utf-8&connectionCollation=utf8mb4_0900_bin",
                "kazuhira",
                "password"
        );
        transactionManager = new LocalTransactionManager(dataSource.getLocalTransaction(getJdbcLogger()));
    }

    public static DomaConfig singleton() {
        return INSTANCE;
    }

    @Override
    public DataSource getDataSource() {
        return dataSource;
    }

    @Override
    public Dialect getDialect() {
        return dialect;
    }

    @Override
    public TransactionManager getTransactionManager() {
        return transactionManager;
    }

    @Override
    public Naming getNaming() {
        return Naming.SNAKE_LOWER_CASE;
    }
}

テストコードを書く

では、テストコードを書いていきます。

テストコードの雛形はこちら。

src/test/java/org/littlewings/testdatabuilder/TestDataBuilderTest.java

package org.littlewings.testdatabuilder;

import java.net.URL;
import java.time.LocalDate;
import java.util.List;
import org.instancio.Instancio;
import org.instancio.Select;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.littlewings.testdatabuilder.dao.AuthorDao;
import org.littlewings.testdatabuilder.dao.AuthorDaoImpl;
import org.littlewings.testdatabuilder.dao.PostDao;
import org.littlewings.testdatabuilder.dao.PostDaoImpl;
import org.littlewings.testdatabuilder.entity.Author;
import org.littlewings.testdatabuilder.entity.Post;

import static org.assertj.core.api.Assertions.assertThat;

class TestDataBuilderTest {
    @BeforeAll
    static void setUpAll() {
        AuthorDao authorDao = new AuthorDaoImpl(DomaConfig.singleton());
        authorDao.createTableIfExistsRecreate();

        PostDao postDao = new PostDaoImpl(DomaConfig.singleton());
        postDao.createTableIfExistsRecreate();
    }

    @BeforeEach
    void setUp() {
        PostDao postDao = new PostDaoImpl(DomaConfig.singleton());
        postDao.deleteAll();

        AuthorDao authorDao = new AuthorDaoImpl(DomaConfig.singleton());
        authorDao.deleteAll();
    }

    // ここにテストを書く！
}

Instancioをそのまま使う

まずはシンプルにInstancioを使ってテストを書いてみます。

こんな感じでしょうか。

    @Test
    void authors() {
        Author katsuo = Instancio.of(Author.class)
                .set(Select.field("firstName"), "カツオ")
                .set(Select.field("age"), 11)
                .create();
        Author wakame = Instancio.of(Author.class)
                .set(Select.field("firstName"), "ワカメ")
                .set(Select.field("age"), 9)
                .create();

        DomaConfig
                .singleton()
                .getTransactionManager()
                .required(() -> {
                    AuthorDao authorDao = new AuthorDaoImpl(DomaConfig.singleton());
                    authorDao.insert(katsuo);
                    authorDao.insert(wakame);

                    Author foundKatsuo = authorDao.selectById(katsuo.id());
                    assertThat(foundKatsuo).isEqualTo(katsuo);

                    Author foundWakame = authorDao.selectById(wakame.id());
                    assertThat(foundWakame).isEqualTo(wakame);
                });
    }

ある意味これもTest Data Builderと言える気はしますが。

Instancioを使ってTest Data Builderを作成する

次はInstancioを使ってTest Data Builderを作ります。

こんな感じでしょうか。

src/test/java/org/littlewings/testdatabuilder/AuthorFactory.java

package org.littlewings.testdatabuilder;

import java.util.function.Consumer;
import org.instancio.Instancio;
import org.instancio.InstancioApi;
import org.instancio.Select;
import org.littlewings.testdatabuilder.dao.AuthorDao;
import org.littlewings.testdatabuilder.entity.Author;

public class AuthorFactory {
    private InstancioApi<Author> authorCreator;
    private AuthorDao authorDao;

    private AuthorFactory(AuthorDao authorDao) {
        this.authorDao = authorDao;
        this.authorCreator = Instancio.of(Author.class)
                .generate(Select.field("id"), gen -> gen.string().minLength(36).maxLength(36))
                .generate(Select.field("firstName"), gen -> gen.string().maxLength(10))
                .generate(Select.field("lastName"), gen -> gen.string().maxLength(10))
                .generate(Select.field("age"), gen -> gen.ints().min(0).max(100));
    }

    public static AuthorFactory anAuthor(AuthorDao authorDao) {
        return new AuthorFactory(authorDao);
    }

    public AuthorFactory firstName(String firstName) {
        authorCreator.set(Select.field("firstName"), firstName);
        return this;
    }

    public AuthorFactory age(int age) {
        authorCreator.set(Select.field("age"), age);
        return this;
    }

    public AuthorFactory with(Consumer<InstancioApi<Author>> consumer) {
        consumer.accept(authorCreator);
        return this;
    }

    public Author build() {
        return authorCreator.create();
    }

    public Author create() {
        Author instance = build();
        authorDao.insert(instance);

        return instance;
    }
}

src/test/java/org/littlewings/testdatabuilder/PostFactory.java

package org.littlewings.testdatabuilder;

import java.net.URL;
import java.time.LocalDate;
import java.util.function.Consumer;
import org.instancio.Instancio;
import org.instancio.InstancioApi;
import org.instancio.Select;
import org.littlewings.testdatabuilder.dao.PostDao;
import org.littlewings.testdatabuilder.entity.Author;
import org.littlewings.testdatabuilder.entity.Post;

public class PostFactory {
    private InstancioApi<Post> postCreator;
    private PostDao postDao;

    private PostFactory(PostDao postDao) {
        this.postDao = postDao;
        this.postCreator = Instancio.of(Post.class)
                .generate(Select.field("id"), gen -> gen.string().minLength(36).maxLength(36))
                .generate(Select.field("title"), gen -> gen.string().maxLength(200))
                .generate(Select.field("url"), gen -> gen.net().url().protocol("https").as(URL::toString));
    }

    public static PostFactory aPost(PostDao postDao) {
        return new PostFactory(postDao);
    }

    public static PostFactory aPost(PostDao postDao, Author author) {
        return aPost(postDao).withAuthor(author);
    }


    public PostFactory date(LocalDate date) {
        postCreator.set(Select.field("date"), date);
        return this;
    }

    public PostFactory with(Consumer<InstancioApi<Post>> consumer) {
        consumer.accept(postCreator);
        return this;
    }

    public PostFactory withAuthor(Author author) {
        postCreator.set(Select.field("authorId"), author.id());
        return this;
    }

    public Post build() {
        return postCreator.create();
    }

    public Post create() {
        Post instance = build();
        postDao.insert(instance);

        return instance;
    }
}

生成するインスタンスの値は少々カスタマイズしてあります。

    private AuthorFactory(AuthorDao authorDao) {
        this.authorDao = authorDao;
        this.authorCreator = Instancio.of(Author.class)
                .generate(Select.field("id"), gen -> gen.string().minLength(36).maxLength(36))
                .generate(Select.field("firstName"), gen -> gen.string().maxLength(10))
                .generate(Select.field("lastName"), gen -> gen.string().maxLength(10))
                .generate(Select.field("age"), gen -> gen.ints().min(0).max(100));
    }


    private PostFactory(PostDao postDao) {
        this.postDao = postDao;
        this.postCreator = Instancio.of(Post.class)
                .generate(Select.field("id"), gen -> gen.string().minLength(36).maxLength(36))
                .generate(Select.field("title"), gen -> gen.string().maxLength(200))
                .generate(Select.field("url"), gen -> gen.net().url().protocol("https").as(URL::toString));
    }

データベースに保存するタイミングをちょっと悩みましたが、オブジェクトの構築時にinsertすることにしました。

    public Author build() {
        return authorCreator.create();
    }

    public Author create() {
        Author instance = build();
        authorDao.insert(instance);

        return instance;
    }

insertせずにインスタンス化まででとどめておくメソッドも用意しています。

こういう役割もあった関係で、Test Data Builderというパターンの割にクラス名をBuilderにせずにFactoryにしました。

使うとこんな感じですね。

    @Test
    void authorsWithBuilder() {
        DomaConfig
                .singleton()
                .getTransactionManager()
                .required(() -> {
                    AuthorDao authorDao = new AuthorDaoImpl(DomaConfig.singleton());

                    Author katsuo = AuthorFactory.anAuthor(authorDao)
                            .firstName("カツオ")
                            .age(11)
                            .create();
                    Author wakame = AuthorFactory.anAuthor(authorDao)
                            .firstName("ワカメ")
                            .age(9)
                            .create();

                    Author foundKatsuo = authorDao.selectById(katsuo.id());
                    assertThat(foundKatsuo).isEqualTo(katsuo);

                    Author foundWakame = authorDao.selectById(wakame.id());
                    assertThat(foundWakame).isEqualTo(wakame);
                });
    }

    @Test
    void postsWithBuilder() {
        DomaConfig
                .singleton()
                .getTransactionManager()
                .required(() -> {
                    AuthorDao authorDao = new AuthorDaoImpl(DomaConfig.singleton());
                    PostDao postDao = new PostDaoImpl(DomaConfig.singleton());

                    Author katsuo = AuthorFactory.anAuthor(authorDao)
                            .firstName("カツオ")
                            .age(11)
                            .create();
                    Author wakame = AuthorFactory.anAuthor(authorDao)
                            .firstName("ワカメ")
                            .age(9)
                            .create();

                    Post katsuoPost1 = PostFactory.aPost(postDao, katsuo)
                            .date(LocalDate.of(2026, 1, 31))
                            .create();

                    Post katsuoPost2 = PostFactory.aPost(postDao, katsuo)
                            .date(LocalDate.of(2026, 2, 5))
                            .create();

                    Post wakamePost1 = PostFactory.aPost(postDao, wakame)
                            .date(LocalDate.of(2026, 2, 1))
                            .create();

                    List<Post> posts = postDao.selectAllOrderByDateDesc();

                    assertThat(posts).hasSize(3);
                    assertThat(posts).isEqualTo(List.of(katsuoPost2, wakamePost1, katsuoPost1));
                });
    }

それから、Test Data Builderとはちょっと言い難いですが、まとめたものも作ってみました。

src/test/java/org/littlewings/testdatabuilder/IsonoFamilyPostFactory.java

package org.littlewings.testdatabuilder;

import java.time.LocalDate;
import java.util.List;
import org.littlewings.testdatabuilder.dao.AuthorDao;
import org.littlewings.testdatabuilder.dao.PostDao;
import org.littlewings.testdatabuilder.entity.Author;
import org.littlewings.testdatabuilder.entity.Post;

public class IsonoFamilyPostFactory {
    private List<AuthorFactory> authorFactories;
    private List<PostFactory> postFactories;

    private IsonoFamilyPostFactory(AuthorDao authorDao, PostDao postDao) {
        this.authorFactories = List.of(
                AuthorFactory.anAuthor(authorDao)
                        .firstName("カツオ")
                        .age(11),
                AuthorFactory.anAuthor(authorDao)
                        .firstName("ワカメ")
                        .age(9)
        );

        this.postFactories = List.of(
                PostFactory.aPost(postDao)
                        .date(LocalDate.of(2026, 1, 31)),
                PostFactory.aPost(postDao)
                        .date(LocalDate.of(2026, 2, 5)),
                PostFactory.aPost(postDao)
                        .date(LocalDate.of(2026, 2, 1))
        );
    }

    public static IsonoFamilyPostFactory family(AuthorDao authorDao, PostDao postDao) {
        return new IsonoFamilyPostFactory(authorDao, postDao);
    }

    public List<Post> create() {
        List<Author> authors = authorFactories.stream().map(AuthorFactory::create).toList();

        postFactories.get(0).withAuthor(authors.get(0));
        postFactories.get(1).withAuthor(authors.get(0));
        postFactories.get(2).withAuthor(authors.get(1));

        return  postFactories.stream().map(PostFactory::create).toList();
    }
}

テスト側。

    @Test
    void isonoFamiry() {
        DomaConfig
                .singleton()
                .getTransactionManager()
                .required(() -> {
                    AuthorDao authorDao = new AuthorDaoImpl(DomaConfig.singleton());
                    PostDao postDao = new PostDaoImpl(DomaConfig.singleton());

                    IsonoFamilyPostFactory isonoFamilyPostFactory = IsonoFamilyPostFactory.family(authorDao, postDao);
                    List<Post> isonoFamilyPosts = isonoFamilyPostFactory.create();

                    List<Post> posts = postDao.selectAllOrderByDateDesc();

                    assertThat(posts).hasSize(isonoFamilyPosts.size());
                    assertThat(posts).isEqualTo(List.of(isonoFamilyPosts.get(1), isonoFamilyPosts.get(2), isonoFamilyPosts.get(0)));
                });
    }

雰囲気を掴むために書いてみましたが、こんなところでしょうか。

実際に書いてみて？

今回、Test Data BuilderとInstancioを組み合わせてみましたが、まあ難しいですね。

最初に思ったように、こうなる感じがすごくしました。

• Builderを作るのが大変
• Builderでカスタマイズされたテストデータを読み解くのが大変
• Builderで作られたGod Object Motherができあがる可能性が高い

Builderの設計が難しいのと、変に凝ると自分しか使えないTest Data Builderができあがりそうだな、と。

またデータベースに保存するタイミングも厄介で、ここにデータ間の依存関係が入ってくるとTest Data Builderの設計が
かなり難しくなります。最後に作ったテストデータをまとめたクラスでそこにチャレンジしようかなと思ったのですが、
今回のエントリーとしては話がややこしくなりすぎるのでやめました。

それから、これを汎用的に作るのは厳しいでしょうね、という印象も持ちました。

ただ課題としてはいいなと思ったので、データ間の依存関係も踏まえたうえでまたチャレンジしたいですね。

おわりに

Object MotherとTest Data Builderについて調べつつ、Test Data BuilderとInstancioを組み合わせてテストデータを作成して
みました。

単純にBuilderを作るだけならいいのですが、実際にテストをこなせるデータを作る仕掛けを考えるとなると一気に難易度が
跳ね上がる気がします。

最後の方にも書きましたが、いい課題だとは思うのでまた考えてみたいです。