【Spring Batch ハンズオン】単体テスト徹底解説！カスタムItemWriterの単体テストでデータ書き込みロジックを徹底検証する

はじめに: カスタムItemWriterテストのベストプラクティスとこの記事で学ぶこと

Spring Batchアプリケーションにおいて、ItemWriterはItemProcessorによって処理されたデータを永続化する最終段階を担う重要なコンポーネントです。

本記事では、EntityManagerを直接利用するカスタムItemWriterを作成し、その振る舞いをMockitoを使って精密に検証する単体テストの実装方法をハンズオン形式で解説します。

この記事の目的:
- Spring BatchのカスタムItemWriterの単体テストに焦点を当て、データ書き込みロジックの検証方法を学びます。
対象読者:
- Spring Batchの基本的な概念を理解しているジュニアエンジニア、テストコードの書き方を学びたい開発者。
この記事で学ぶこと:
- カスタムItemWriterの役割、単体テストの重要性、Mockitoを使ったモック化、具体的なテストコードの実装と検証。
前提知識:
- Spring Batchの全体像やテスト戦略については、モダンJavaバッチ開発：Spring Batchテスト完全攻略：信頼性の高いバッチシステムを構築するテスト戦略と自動化ガイドをご参照ください。
- ItemReaderの単体テストはこちら、ItemProcessorの単体テストはこちらをご参照ください。
- JpaItemWriterの単体テストはこちらをご参照ください。

1. Spring BatchにおけるItemWriterの役割
2. なぜItemWriterの単体テストが必要なのか？
3. テスト戦略の概要
4. テスト対象のItemWriterと関連エンティティ
- 4-1. テスト対象の仕様
- 4-2. Productエンティティ
- 4-3. ProcessedProductエンティティ
- 4-4. カスタムItemWriter: ProcessedProductWriter
- 4-5. バッチジョブ: processProductJob
5. テスト環境の準備
- 5-1. 補足：モックオブジェクトの準備と振る舞いの定義
- 5-2. 依存関係の追加
6. 単体テストの実装
- 6-1. テストのセットアップ
7. ItemWriterの単体テスト実装
- 7-1. テストケース1: 複数のアイテムが正常に書き込まれるケース
- 7-2. テストケース2: アイテムがない場合に何も書き込まれないケース
- 7-3. テストケース3: 単一のアイテムが書き込まれるケース
- 7-4. テストケース4: (オプション) 書き込み中に例外が発生するケース
8. テストの実行と結果確認
- 8-1. コマンドラインから実行する (Maven)
- 8-2. IDEから実行する
9.【補足】なぜSpring Batch標準のJpaItemWriterではなく、カスタムItemWriterを実装するのか？
- ビジネスロジックの実装方法の違い
- カスタムItemWriterのよくあるユースケース
- ビジネスロジックのテスト対象の違い
まとめ

対象読者

Spring BatchでカスタムItemWriterの実装とテスト方法を学びたい開発者
ItemWriterの単体テストの具体的な手法（特にMockitoを使ったモック化）を知りたいエンジニア
Spring Batchアプリケーションの品質向上に関心のあるアーキテクトやチームリーダー
Spring Batchの基本的な概念を理解しており、より実践的なテスト技術を習得したい方

1. Spring Batchにおける`ItemWriter`の役割

ItemWriterは、ItemProcessorから受け取った（またはItemReaderから直接受け取った）アイテムのリストを、データベース、ファイル、メッセージキューなどの外部システムに書き込む役割を担うコンポーネントです。

ItemWriterの基本:
- 処理済みのアイテムを永続化する。通常、リスト形式でアイテムを受け取り、一括で書き込み処理を行います。
主な実装例:
- JpaItemWriterのような既存のItemWriter（JPAエンティティをデータベースに書き込む）の他に、FlatFileItemWriter（フラットファイルに書き込む）、JdbcBatchItemWriter（JDBCを使ってデータベースに書き込む）など、様々なデータシンクに対応した実装が提供されています。
なぜ重要か:
- ItemWriterはバッチ処理の最終的な結果を決定する部分であり、ここでの問題（例: データ書き込みの失敗、データ不整合）は、ビジネス上の損失やシステム全体の信頼性低下に直結します。
- 正確かつ効率的なデータ永続化は、バッチアプリケーションの成功に不可欠です。

2. なぜItemWriterの単体テストが必要なのか？

ItemWriterは、バッチ処理の最終段階として、データベースやファイルへの書き込みを担当する重要なコンポーネントです。
ここでのロジックに不備があると、データ不整合やパフォーマンス低下に直結します。

書き込みロジックの正確性検証:
- データをデータベースに保存したり、ファイルに出力したりするロジックが期待通りに動作するかを検証します。
- 例えば、カスタムItemWriterであればEntityManager.merge()が正しく呼び出されているか、FlatFileItemWriterであれば指定されたフォーマットでファイルに書き込まれているか、などです。
外部依存のモック化:
- 実際のデータベースやファイルシステムへのアクセスを伴わないため、テストが高速に実行でき、開発サイクルを短縮できます。
- 外部システムへの依存をモック化することで、テストの安定性と再現性が向上します。
冪等性の検証:
- 特に更新処理を含むItemWriterの場合、複数回実行されても同じ結果になる「冪等性」が保証されているかを検証することが重要です。
エラーハンドリングの検証:
- 書き込み中にエラーが発生した場合に、ItemWriterが適切に例外をスローしたり、エラーログを出力したりするなど、期待されるエラーハンドリングが行われるかを検証します。
問題の早期発見:
- 開発の早い段階でItemWriter内のバグを発見し、修正コストを大幅に削減します。

ItemWriterの単体テストは、バッチ処理の出力部分の正確性と信頼性を保証するために不可欠です。

3. テスト戦略の概要

本記事では、カスタムItemWriterの単体テストに特化し、以下の戦略で進めます。

テスト対象の特定:
- カスタムItemWriterであるProcessedProductWriterをテスト対象とし、その依存関係（EntityManager）を明確にします。
モック化:
- Mockitoを用いて、データベースアクセスに関連する依存関係をモック化します。これにより、実際のデータベースに接続することなく、ItemWriterのロジックのみをテストします。
テストデータの準備:
- カスタムItemWriterのwrite()メソッドに渡す入力データ（Productエンティティのリスト）を準備します。
- 様々なシナリオ（複数アイテム、単一アイテム、空リスト、例外発生時など）をシミュレートします。
振る舞いの検証:
- カスタムItemWriterが依存オブジェクトのメソッド（例: EntityManager.merge(), flush(), clear()) を正しい引数で、正しい回数呼び出しているかをMockito.verify()などを用いて検証します。

この戦略により、カスタムItemWriterのデータ書き込みロジックが、外部環境に左右されずに正しく機能することを保証します。

4. テスト対象のItemWriterと関連エンティティ

本記事では、前回の記事で定義したProductエンティティを使用し、そのProductエンティティをProcessedProductとしてデータベースに書き込むカスタムItemWriterであるProcessedProductWriterをテスト対象とします。

4-1. テスト対象の仕様

目的:
- Productエンティティのリストを受け取り、データベースに永続化すること。
入力:
- List<Product>
出力:
- なし（データベースへの書き込み）
振る舞い:
- 受け取ったProductエンティティをEntityManager.merge()メソッドを使用してデータベースに保存または更新する。
- 書き込み後、EntityManager.flush()を呼び出して変更をデータベースに同期する。
- EntityManager.clear()を呼び出して永続化コンテキストをクリアする。
- 空のリストが渡された場合は、何も処理を行わない。
- 書き込み中にデータベース関連の例外が発生した場合は、適切に例外をスローする。

4-2. Productエンティティ

テスト対象のItemWriterが書き込むProductエンティティの定義は以下の通りです。

Product.java

package com.example.springbatchh2crud.model;

import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import java.math.BigDecimal;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

@Entity
@Table(name = "products")
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class Product {

    @Id
    private Long id;

    private String name;
    private String description;
    private BigDecimal price;
    private String status;
    private boolean invalid;
}

package com.example.springbatchh2crud.model;

import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import java.math.BigDecimal;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

@Entity
@Table(name = "products")
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class Product {

    @Id
    private Long id;

    private String name;
    private String description;
    private BigDecimal price;
    private String status;
    private boolean invalid;
}

4-3. `ProcessedProduct`エンティティ

まず、書き込み先となる新しいエンティティProcessedProductを定義します。

ProcessedProduct.java

// src/main/java/com/example/springbatchh2crud/model/ProcessedProduct.java
@Entity
@Table(name = "processed_products")
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class ProcessedProduct {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private Long originalProductId;
    private String name;
    private String description;
    private BigDecimal price;
    private LocalDateTime processedAt;
}

// src/main/java/com/example/springbatchh2crud/model/ProcessedProduct.java
@Entity
@Table(name = "processed_products")
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class ProcessedProduct {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private Long originalProductId;
    private String name;
    private String description;
    private BigDecimal price;
    private LocalDateTime processedAt;
}

4-4. カスタムItemWriter: `ProcessedProductWriter`

次に、このハンズオンの主役であるProcessedProductWriterを実装します。@PersistenceContextでEntityManagerをインジェクションし、writeメソッド内でProductをProcessedProductに変換して書き込みます。

ポイントは、writeメソッドの最後にentityManager.flush()とentityManager.clear()を呼び出している点です。
これは、チャンク処理において永続化コンテキストの状態を適切に管理するためのベストプラクティスです。

ProcessedProductWriter.java

// src/main/java/com/example/springbatchh2crud/writer/ProcessedProductWriter.java
@Component
public class ProcessedProductWriter implements ItemWriter<Product> {

    @PersistenceContext
    private EntityManager entityManager;

    @Override
    @Transactional
    public void write(Chunk<? extends Product> chunk) throws Exception {
        if (chunk.isEmpty()) {
            return;
        }

        for (Product product : chunk.getItems()) {
            ProcessedProduct processedProduct = ProcessedProduct.builder()
                    .originalProductId(product.getId())
                    .name(product.getName())
                    .description(product.getDescription())
                    .price(product.getPrice())
                    .processedAt(LocalDateTime.now())
                    .build();
            entityManager.merge(processedProduct);
        }
        entityManager.flush();
        entityManager.clear();
    }
}

// src/main/java/com/example/springbatchh2crud/writer/ProcessedProductWriter.java
@Component
public class ProcessedProductWriter implements ItemWriter<Product> {

    @PersistenceContext
    private EntityManager entityManager;

    @Override
    @Transactional
    public void write(Chunk<? extends Product> chunk) throws Exception {
        if (chunk.isEmpty()) {
            return;
        }

        for (Product product : chunk.getItems()) {
            ProcessedProduct processedProduct = ProcessedProduct.builder()
                    .originalProductId(product.getId())
                    .name(product.getName())
                    .description(product.getDescription())
                    .price(product.getPrice())
                    .processedAt(LocalDateTime.now())
                    .build();
            entityManager.merge(processedProduct);
        }
        entityManager.flush();
        entityManager.clear();
    }
}

4-5. バッチジョブ: `processProductJob`

このWriterを使用する新しいバッチジョブprocessProductJobをProcessProductJobConfig.javaで定義します。

ProcessProductJobConfig.java

// /src/main/java/com/example/springbatchh2crud/config/ProcessProductJobConfig.java
@Configuration
@RequiredArgsConstructor
public class ProcessProductJobConfig {

    private final JobRepository jobRepository;
    private final PlatformTransactionManager transactionManager;
    private final EntityManagerFactory entityManagerFactory;
    private final ProcessedProductWriter processedProductWriter;

    @Bean
    public Job processProductJob() {
        return new JobBuilder("processProductJob", jobRepository)
                .start(processProductStep())
                .build();
    }

    @Bean
    public Step processProductStep() {
        return new StepBuilder("processProductStep", jobRepository)
                .<Product, Product>chunk(10, transactionManager)
                .reader(processProductReader())
                .writer(processedProductWriter)
                .build();
    }

    @Bean
    public JpaPagingItemReader<Product> processProductReader() {
        return new JpaPagingItemReaderBuilder<Product>()
                .name("processProductReader")
                .entityManagerFactory(entityManagerFactory)
                .queryString("SELECT p FROM Product p ORDER BY p.id ASC")
                .pageSize(10)
                .build();
    }
}

// /src/main/java/com/example/springbatchh2crud/config/ProcessProductJobConfig.java
@Configuration
@RequiredArgsConstructor
public class ProcessProductJobConfig {

    private final JobRepository jobRepository;
    private final PlatformTransactionManager transactionManager;
    private final EntityManagerFactory entityManagerFactory;
    private final ProcessedProductWriter processedProductWriter;

    @Bean
    public Job processProductJob() {
        return new JobBuilder("processProductJob", jobRepository)
                .start(processProductStep())
                .build();
    }

    @Bean
    public Step processProductStep() {
        return new StepBuilder("processProductStep", jobRepository)
                .<Product, Product>chunk(10, transactionManager)
                .reader(processProductReader())
                .writer(processedProductWriter)
                .build();
    }

    @Bean
    public JpaPagingItemReader<Product> processProductReader() {
        return new JpaPagingItemReaderBuilder<Product>()
                .name("processProductReader")
                .entityManagerFactory(entityManagerFactory)
                .queryString("SELECT p FROM Product p ORDER BY p.id ASC")
                .pageSize(10)
                .build();
    }
}

単体テストでは、EntityManagerの振る舞いをMockitoでモック化してテストします。

5. テスト環境の準備

5-1. 補足：モックオブジェクトの準備と振る舞いの定義

カスタムItemWriterの単体テストでは、実際のデータベースアクセスを伴わないように、EntityManagerFactoryやEntityManagerといった外部依存をモック化します。

これにより、テストの実行速度を向上させ、外部環境に左右されない安定したテストを実現します。

モック化前: 本番環境での依存関係

本番環境では、ProcessedProductWriterはEntityManagerを介して実際のデータベースとのやり取りを行います。

モック化後: テスト環境での依存関係

単体テストでは、EntityManagerをMockitoでモック化し、ProcessedProductWriterがこのモックオブジェクトとやり取りするように設定します。

これにより、データベースへの実際のアクセスなしにItemWriterのロジックを検証できます。

5-2. 依存関係の追加

ItemWriterの単体テストを行うために、以下の依存関係をpom.xml（Mavenの場合）またはbuild.gradle（Gradleの場合）に追加します。

Mavenの場合 (pom.xml):

<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-junit-jupiter</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-api</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-engine</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.assertj</groupId>
    <artifactId>assertj-core</artifactId>
    <scope>test</scope>
</dependency>

<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-junit-jupiter</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-api</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-engine</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.assertj</groupId>
    <artifactId>assertj-core</artifactId>
    <scope>test</scope>
</dependency>

Gradleの場合 (build.gradle):

testImplementation 'org.mockito:mockito-junit-jupiter'
testImplementation 'org.junit.jupiter:junit-jupiter-api'
testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine'
testImplementation 'org.assertj:assertj-core'

testImplementation 'org.mockito:mockito-junit-jupiter'
testImplementation 'org.junit.jupiter:junit-jupiter-api'
testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine'
testImplementation 'org.assertj:assertj-core'

6. 単体テストの実装

ProcessedProductWriterUnitTest.javaで、EntityManagerの振る舞いをMockitoでモック化してテストします。

モック化とは、テスト対象のコンポーネントが依存する外部コンポーネント（データベース、外部サービスなど）を「模擬的なオブジェクト（モック）」に置き換えることです。

6-1. テストのセットアップ

@ExtendWith(MockitoExtension.class)アノテーションを使用することで、Mockitoの機能をJUnit 5で利用できるようになります。

@ExtendWith(MockitoExtension.class)でMockitoを有効化し、@MockでEntityManagerのモックを、@InjectMocksでテスト対象のProcessedProductWriterを準備します。

ProcessedProductWriterUnitTest.java

// src/test/java/com/example/springbatchh2crud/writer/ProcessedProductWriterUnitTest.java

import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import com.example.springbatchh2crud.model.Product;
import com.example.springbatchh2crud.model.ProcessedProduct;
import jakarta.persistence.EntityManager;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.batch.item.Chunk;

// Productエンティティは適切なパッケージ名に修正してください
// import com.example.batch.Product;

@ExtendWith(MockitoExtension.class)
class ProcessedProductWriterUnitTest {

    @Mock
    private EntityManager entityManager;

    @InjectMocks
    private ProcessedProductWriter processedProductWriter;

    private List<Product> products;

    @BeforeEach
    void setUp() {
        products = new ArrayList<>();
    }

    // ここにテストメソッドを記述していきます
}

// src/test/java/com/example/springbatchh2crud/writer/ProcessedProductWriterUnitTest.java

import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import com.example.springbatchh2crud.model.Product;
import com.example.springbatchh2crud.model.ProcessedProduct;
import jakarta.persistence.EntityManager;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.batch.item.Chunk;

// Productエンティティは適切なパッケージ名に修正してください
// import com.example.batch.Product;

@ExtendWith(MockitoExtension.class)
class ProcessedProductWriterUnitTest {

    @Mock
    private EntityManager entityManager;

    @InjectMocks
    private ProcessedProductWriter processedProductWriter;

    private List<Product> products;

    @BeforeEach
    void setUp() {
        products = new ArrayList<>();
    }

    // ここにテストメソッドを記述していきます
}

これにより、テスト対象のロジックのみを独立して、高速かつ安定して検証できます。

`@Mock`と`@InjectMocks`の役割 (ItemWriterのテストにおける考慮事項)

@Mock:
- このアノテーションをフィールドに付与すると、Mockitoがその型のモックオブジェクトを自動的に生成し、テスト実行前に注入してくれます。
- ItemWriterが依存する外部サービス（例: EntityManagerFactory, EntityManager, JpaRepositoryなど）がある場合に利用します。
- モックオブジェクトは、実際のオブジェクトの振る舞いをシミュレートするために使用され、特定のメソッド呼び出しに対して定義した値を返したり、例外をスローしたりすることができます。
@InjectMocks:
- このアノテーションをテスト対象のクラスのフィールドに付与すると、Mockitoがそのインスタンスを自動的に生成し、@Mockで作成されたモックオブジェクトをそのインスタンスのコンストラクタやフィールドに自動的に注入してくれます。
- これにより、テスト対象のクラスの初期化と依存関係の解決が容易になります。

7. ItemWriterの単体テスト実装

それでは、ProcessedProductWriterUnitTestクラスに具体的なテストメソッドを実装していきましょう。

ItemWriterの単体テストでは、ItemProcessorから受け取ったアイテムのリストに対して、EntityManagerのmerge()メソッドが期待通りに呼び出されることをMockito.verify()を使って検証するのが一般的です。

7-1. テストケース1: 複数のアイテムが正常に書き込まれるケース

このテストケースでは、ItemWriterが複数のProductエンティティをデータベースに書き込もうとするとき、EntityManager.merge()が各アイテムに対して一度ずつ呼び出され、その後flush()とclear()が呼び出されることを検証します。

ProcessedProductWriterUnitTest.java

// ProcessedProductWriterUnitTestクラス内に追加
@Test
@DisplayName("テストケース1: 複数のアイテムが正常に書き込まれるケース")
void testWrite_multipleItems() throws Exception {
    // Arrange
    products.add(new Product(1L, "Test Product 1", "Desc 1", new BigDecimal("10.00"), "ACTIVE", false));
    products.add(new Product(2L, "Test Product 2", "Desc 2", new BigDecimal("20.00"), "ACTIVE", false));
    Chunk<Product> chunk = new Chunk<>(products);

    // Act
    processedProductWriter.write(chunk);

    // Assert
    verify(entityManager, times(2)).merge(any(ProcessedProduct.class));
    verify(entityManager, times(1)).flush();
    verify(entityManager, times(1)).clear();
}

// ProcessedProductWriterUnitTestクラス内に追加
@Test
@DisplayName("テストケース1: 複数のアイテムが正常に書き込まれるケース")
void testWrite_multipleItems() throws Exception {
    // Arrange
    products.add(new Product(1L, "Test Product 1", "Desc 1", new BigDecimal("10.00"), "ACTIVE", false));
    products.add(new Product(2L, "Test Product 2", "Desc 2", new BigDecimal("20.00"), "ACTIVE", false));
    Chunk<Product> chunk = new Chunk<>(products);

    // Act
    processedProductWriter.write(chunk);

    // Assert
    verify(entityManager, times(2)).merge(any(ProcessedProduct.class));
    verify(entityManager, times(1)).flush();
    verify(entityManager, times(1)).clear();
}

解説:

Productオブジェクトを2つ含むリストを準備し、itemWriter.write(products)を呼び出します。
verify(entityManager, times(1)).merge(product1)のように、entityManagerモックのmerge()メソッドがproduct1を引数として一度だけ呼び出されたことを検証します。同様にproduct2についても検証します。
verify(entityManager, times(1)).flush()とverify(entityManager, times(1)).clear()で、カスタムItemWriterが内部でEntityManagerのflush()とclear()を呼び出していることも検証します。これらは、トランザクションのコミットとEntityManagerのキャッシュクリアに関連する重要な操作です。

7-2. テストケース2: アイテムがない場合に何も書き込まれないケース

このテストケースでは、ItemWriterに空のリストが渡された場合に、EntityManagerのmerge()、flush()、clear()メソッドが一度も呼び出されないことを検証します。

ProcessedProductWriterUnitTest.java

// ProcessedProductWriterUnitTestクラス内に追加
@Test
@DisplayName("テストケース2: アイテムがない場合に何も書き込まれないケース")
void testWrite_noItems() throws Exception {
    // Arrange
    Chunk<Product> chunk = new Chunk<>(Collections.emptyList());

    // Act
    processedProductWriter.write(chunk);

    // Assert
    verify(entityManager, never()).merge(any());
    verify(entityManager, never()).flush();
    verify(entityManager, never()).clear();
}

// ProcessedProductWriterUnitTestクラス内に追加
@Test
@DisplayName("テストケース2: アイテムがない場合に何も書き込まれないケース")
void testWrite_noItems() throws Exception {
    // Arrange
    Chunk<Product> chunk = new Chunk<>(Collections.emptyList());

    // Act
    processedProductWriter.write(chunk);

    // Assert
    verify(entityManager, never()).merge(any());
    verify(entityManager, never()).flush();
    verify(entityManager, never()).clear();
}

解説:

空のリストをitemWriter.write(products)に渡します。
verify(entityManager, never()).merge(any())のように、never()モディファイアを使って、entityManagerモックのmerge()メソッドが一度も呼び出されなかったことを検証します。flush()とclear()についても同様に検証します。

7-3. テストケース3: 単一のアイテムが書き込まれるケース

このテストケースでは、ItemWriterに単一のProductエンティティを含むリストが渡された場合に、EntityManager.merge()がそのアイテムに対して一度だけ呼び出され、その後flush()とclear()が呼び出されることを検証します。

ProcessedProductWriterUnitTest.java

// ProcessedProductWriterUnitTestクラス内に追加
@Test
@DisplayName("テストケース3: 単一のアイテムが書き込まれるケース")
void testWrite_singleItem() throws Exception {
    // ...
    // Assert
    verify(entityManager, times(1)).merge(any(ProcessedProduct.class));
    verify(entityManager, times(1)).flush();
    verify(entityManager, times(1)).clear();
}

// ProcessedProductWriterUnitTestクラス内に追加
@Test
@DisplayName("テストケース3: 単一のアイテムが書き込まれるケース")
void testWrite_singleItem() throws Exception {
    // ...
    // Assert
    verify(entityManager, times(1)).merge(any(ProcessedProduct.class));
    verify(entityManager, times(1)).flush();
    verify(entityManager, times(1)).clear();
}

解説:

単一のProductオブジェクトを含むリストを準備し、itemWriter.write(products)を呼び出します。
verify(entityManager, times(1)).merge(product)のように、times(1)モディファイアを使って、entityManagerモックのmerge()メソッドがproductを引数として一度だけ呼び出されたことを検証します。flush()とclear()についても同様に検証します。

7-4. テストケース4: (オプション) 書き込み中に例外が発生するケース

ItemWriterの単体テストでは、書き込み中に外部システム（この場合はEntityManager）が例外をスローした場合に、ItemWriterがその例外を適切に処理するか（通常はそのまま再スローする）を検証することも重要です。

ProcessedProductWriterUnitTest.java

// ProcessedProductWriterUnitTestクラス内に追加
import org.junit.jupiter.api.Assertions; // Assertionsクラスをインポート

// ...

@Test
@DisplayName("テストケース4: 書き込み中に例外が発生するケース")
void testWrite_throwsException() {
    // Arrange
    // ...
    when(entityManager.merge(any(ProcessedProduct.class))).thenThrow(new RuntimeException("DB connection failed"));

    // Act & Assert
    RuntimeException exception = assertThrows(RuntimeException.class, () -> {
        processedProductWriter.write(chunk);
    });

    // ...
    verify(entityManager, times(1)).merge(any(ProcessedProduct.class));
    verify(entityManager, never()).flush();
    verify(entityManager, never()).clear();
}

// ProcessedProductWriterUnitTestクラス内に追加
import org.junit.jupiter.api.Assertions; // Assertionsクラスをインポート

// ...

@Test
@DisplayName("テストケース4: 書き込み中に例外が発生するケース")
void testWrite_throwsException() {
    // Arrange
    // ...
    when(entityManager.merge(any(ProcessedProduct.class))).thenThrow(new RuntimeException("DB connection failed"));

    // Act & Assert
    RuntimeException exception = assertThrows(RuntimeException.class, () -> {
        processedProductWriter.write(chunk);
    });

    // ...
    verify(entityManager, times(1)).merge(any(ProcessedProduct.class));
    verify(entityManager, never()).flush();
    verify(entityManager, never()).clear();
}

解説:

doThrow(new RuntimeException("...")).when(entityManager).merge(product)を使って、entityManager.merge(product)が呼び出された際にRuntimeExceptionをスローするようにモックの振る舞いを設定します。
Assertions.assertThrows(RuntimeException.class, () -> { itemWriter.write(products); })を使って、itemWriter.write()の実行がRuntimeExceptionをスローすることを検証します。
例外がスローされた後でも、merge()メソッドが一度は呼び出されたことをverify()で確認します。また、例外発生時にはflush()やclear()が呼び出されないことをnever()で検証します。

8. テストの実行と結果確認

作成した単体テストは、以下の方法で実行できます。

8-1. コマンドラインから実行する (Maven)

プロジェクトのルートディレクトリで以下のコマンドを実行すると、今回作成したテストクラス(ProcessedProductWriterUnitTest)のみを実行できます。

./mvnw test -Dtest=ProcessedProductWriterUnitTest

./mvnw test -Dtest=ProcessedProductWriterUnitTest

ビルド全体の一環としてすべてのテストを実行する場合は、単純にtestゴールを実行します。

./mvnw test

./mvnw test

8-2. IDEから実行する

お使いの統合開発環境（IDE）の機能を使って、より簡単にテストを実行することもできます。

IntelliJ IDEA / Eclipse:
src/test/javaディレクトリからProcessedProductWriterUnitTest.javaファイルを開きます。
クラス名または各テストメソッド（例: testWrite_multipleItems）の横に表示される緑色の実行アイコン（▶）をクリックし、「Run ‘…’」を選択します。
Visual Studio Code:
Testingビュー（フラスコのアイコン）をサイドバーから開きます。
ProcessedProductWriterUnitTestを見つけ、実行したいテストケースの横にある再生ボタンをクリックするか、クラス全体をまとめて実行します。

テストが成功すると、IDEのコンソールやテスト結果ウィンドウに、すべてのテストがパスしたことを示す緑色のインジケータが表示されます。

以上で、カスタムItemWriterの実装と、その振る舞いを保証する単体テストの作成は完了です。

9.【補足】なぜSpring Batch標準の`JpaItemWriter`ではなく、`カスタムItemWriter`を実装するのか？

Spring Batchには、JPAを利用するための標準的なItemWriterとしてJpaItemWriterが提供されています。
なぜこのハンズオンではこの標準のJpaItemWriter を使わずに、ItemWriterインターフェースを直接実装したカスタムItemWriterなのでしょうか？

ビジネスロジックの実装方法の違い

最大の理由は、「JpaItemWriter」では実現できない、「複雑なビジネスロジック」を開発者が実装するためです。開発者は、ItemWriterインターフェースを直接実装することで、EntityManagerをクラスのメンバーとして直接制御して永続化処理を実装します。

表：ビジネスロジック実装内容の比較

実装方法	`カスタムItemWriter` を直接実装（今回）	`JpaItemWriter` を利用
目的	複雑なロジックや精密なテストを実現する	定型的な永続化処理を簡単に実装する
テストの粒度	`EntityManager`など、内部コンポーネントとの相互作用まで検証可能	`Writer`全体のI/O（入力と結果）の検証が主

次に、カスタムItemWriterを使う、ユースケースを見ていきましょう。

`カスタムItemWriter`のよくあるユースケース

1. 非標準データストアへの書き込み

概要: Spring Batchが標準で提供するItemWriter（JpaItemWriter, JdbcBatchItemWriter, FlatFileItemWriterなど）では対応できないような、特殊なデータストアや外部システムにデータを書き込む必要がある場合にカスタムItemWriterを実装します。
例: REST APIエンドポイント、メッセージキュー（Kafka, RabbitMQなど）、クラウドストレージ（Amazon S3, Google Cloud Storageなど）、またはレガシーシステム固有のインターフェースへの連携などが挙げられます。

2. 複数の宛先への条件付き書き込み

概要: 処理されたデータの内容や特定の条件に基づいて、複数の異なる出力先へデータを書き分ける必要がある場合にカスタムItemWriterを使用します。
例: 正常に処理されたデータはデータベースに、エラーが発生したデータは別途ログファイルやエラーキューに書き込む、といったシナリオが考えられます。

3. 書き込み時の複雑なビジネスロジック

概要: ItemProcessorで完了できない、またはItemWriterの書き込みコンテキスト（例: トランザクション）へのアクセスが必要な、より複雑なビジネスロジックを実装する必要がある場合にカスタムItemWriterを使用します。
例: 1つの入力アイテムから複数の関連するエンティティを作成して保存する、書き込み直前に複数のテーブルにまたがる複雑なバリデーションを実行する、集計データを計算して別のテーブルに保存する、などが挙げられます。

おしまいに、テスト対象についても、考え方を整理しておきます。

ビジネスロジックのテスト対象の違い

カスタムItemWriterをテストする際には 「誰のコードをテストしているのか？」 という責任範囲を意識する必要があります。

JpaItemWriterは、開発者にフレームワークとして提供され、我々がテストする必要はありません。

その一方で、カスタムItemWriterは、ItemWriterインタフェースを用いて、複雑なビジネスロジックを我々が直接実装します。
この、直接実装したビジネスロジックがテスト対象となります。

表：テスト範囲の比較

テスト範囲	`カスタムItemWriter`	`JpaItemWriter`（フレームワーク提供）
テスト対象	私たちが書いた `write`メソッド内のロジック	私たちが書いた設定と、それを使った結果
適切なテスト手法	Mockitoによる振る舞い検証	`@DataJpaTest`による結果検証

まとめ

本記事では、Spring BatchにおけるカスタムItemWriterの単体テストに焦点を当て、EntityManagerを直接操作するProcessedProductWriterの実装とその検証方法を詳細に解説しました。

Mockitoを用いた依存関係のモック化により、外部システムに依存せず、ItemWriterのビジネスロジックが期待通りに機能することを確認するテスト戦略を確立できます。
複数のアイテム、空のリスト、単一のアイテム、そして例外発生時のシナリオに対応するテストケースを通じて、堅牢なバッチ処理を実現するためのテストの重要性を実感いただけたかと思います。
また、Spring Batch標準のJpaItemWriterとの比較を通じて、カスタムItemWriterが複雑なビジネスロジックや非標準データストアへの書き込み、複数の宛先への条件付き書き込みにおいて、いかに強力な選択肢となり得るかを考察しました。

この知識を活用し、信頼性の高いSpring Batchアプリケーション開発にお役立てください。

免責事項

本記事は、Spring BatchのItemWriterの単体テストに関する情報を提供することを目的としています。記事の内容は執筆時点での情報に基づいており、Spring Batchや関連ライブラリの将来のバージョンアップにより、記述内容が変更される可能性があります。本記事で提供されるコードや情報は、読者自身の責任においてご利用ください。コードの利用、または記事の内容に基づいて実施されたいかなる行為によって生じたいかなる損害についても、筆者および公開元は一切の責任を負いません。各自の環境やプロジェクトの要件に合わせて、適切に調整し、十分な検証を行ってください。

Post Views: 6

はじめに: カスタムItemWriterテストのベストプラクティスとこの記事で学ぶこと

目次

対象読者

1. Spring BatchにおけるItemWriterの役割

2. なぜItemWriterの単体テストが必要なのか？

3. テスト戦略の概要

4. テスト対象のItemWriterと関連エンティティ

4-1. テスト対象の仕様

4-2. Productエンティティ

4-3. ProcessedProductエンティティ

4-4. カスタムItemWriter: ProcessedProductWriter

4-5. バッチジョブ: processProductJob

5. テスト環境の準備

5-1. 補足：モックオブジェクトの準備と振る舞いの定義

モック化前: 本番環境での依存関係

モック化後: テスト環境での依存関係

5-2. 依存関係の追加

6. 単体テストの実装

6-1. テストのセットアップ

@Mockと@InjectMocksの役割 (ItemWriterのテストにおける考慮事項)

7. ItemWriterの単体テスト実装

7-1. テストケース1: 複数のアイテムが正常に書き込まれるケース

7-2. テストケース2: アイテムがない場合に何も書き込まれないケース

7-3. テストケース3: 単一のアイテムが書き込まれるケース

7-4. テストケース4: (オプション) 書き込み中に例外が発生するケース

8. テストの実行と結果確認

8-1. コマンドラインから実行する (Maven)

8-2. IDEから実行する

9.【補足】なぜSpring Batch標準のJpaItemWriterではなく、カスタムItemWriterを実装するのか？

ビジネスロジックの実装方法の違い

カスタムItemWriterのよくあるユースケース

1. 非標準データストアへの書き込み

2. 複数の宛先への条件付き書き込み

3. 書き込み時の複雑なビジネスロジック

ビジネスロジックのテスト対象の違い

まとめ

免責事項

SNSでもご購読できます。

コメントを残す コメントをキャンセル

RSS

投稿記事

カテゴリー

最近の投稿

アーカイブ

1. Spring Batchにおける`ItemWriter`の役割

4-3. `ProcessedProduct`エンティティ

4-4. カスタムItemWriter: `ProcessedProductWriter`

4-5. バッチジョブ: `processProductJob`

`@Mock`と`@InjectMocks`の役割 (ItemWriterのテストにおける考慮事項)

9.【補足】なぜSpring Batch標準の`JpaItemWriter`ではなく、`カスタムItemWriter`を実装するのか？

`カスタムItemWriter`のよくあるユースケース

コメントを残すコメントをキャンセル