Mockito は、Java アプリケーションの モック と ユニットテスト に使用される強力な Java フレームワークです。この実験（Lab）では、Mockito におけるスパイの概念を探求します。スパイは、部分的なモックとして機能するユニークなテストツールです。オブジェクトとのインタラクションを追跡しながら、実際のメソッドの呼び出しを許可します。
この二重の動作により、スパイはオブジェクトとのインタラクションを検証したいが、実際の機能を実行する必要がある場合に特に役立ちます。この実験を通して、さまざまなアプローチを使用してスパイを作成する方法、スパイの動作をスタブする方法を理解し、スパイとモックを比較して、その主な違いを明らかにします。
このステップでは、プロジェクト構造を設定し、Mockito におけるスパイとは何かを理解します。スパイを使用すると、実際のオブジェクトのメソッド呼び出しを追跡しながら、その実際の実装を使用できます。
まず、この実験（Lab）のメイン Java ファイルを作成しましょう。WebIDE で、~/project ディレクトリに MockitoSpyDemo.java という新しいファイルを作成します。
必要な依存関係をインポートするために、次のコードを追加します。
import org.junit.Test;
import org.junit.Before;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.mockito.Spy;
import org.mockito.MockitoAnnotations;
import org.mockito.exceptions.misusing.NotAMockException;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.ArrayList;
import java.util.List;
import static org.junit.Assert.*;
public class MockitoSpyDemo {
public static void main(String[] args) {
System.out.println("This is a Mockito Spy demonstration.");
System.out.println("To run the tests, you need to use JUnit.");
}
}Mockito のスパイは、実際のオブジェクトをラップするもので、次のことができます。
スパイを、オブジェクトに何が起こっているかを監視するオブザーバーとして考えてください。ただし、特別にプログラムされていない限り、通常の動作を妨げることはありません。
スパイの基本的な使用法を示す最初のテストメソッドを追加しましょう。次のメソッドを MockitoSpyDemo クラスに追加します。
@Test
public void basicSpyExample() {
// Create a list and spy on it
List<String> realList = new ArrayList<>();
List<String> spyList = Mockito.spy(realList);
// Using the spy to add an item (the real method is called)
spyList.add("Hello");
// Verify the interaction happened
Mockito.verify(spyList).add("Hello");
// The real method was called, so the list actually has the item
assertEquals(1, spyList.size());
assertEquals("Hello", spyList.get(0));
System.out.println("Basic Spy Example - Spy List Content: " + spyList);
System.out.println("Basic Spy Example - Spy List Size: " + spyList.size());
}コードをコンパイルして実行し、動作を確認しましょう。
cd ~/project
javac -cp lib/junit.jar:lib/mockito-core.jar:lib/byte-buddy.jar:lib/byte-buddy-agent.jar:lib/objenesis.jar:lib/hamcrest-core.jar MockitoSpyDemo.java
java -cp .:lib/junit.jar:lib/mockito-core.jar:lib/byte-buddy.jar:lib/byte-buddy-agent.jar:lib/objenesis.jar:lib/hamcrest-core.jar MockitoSpyDemo
次の出力が表示されるはずです。
This is a Mockito Spy demonstration.
To run the tests, you need to use JUnit.メインメソッドは正しく実行されます。ただし、テストを実行するには JUnit を使用する必要があります。この実験（Lab）のために複雑な JUnit ランナーを設定する代わりに、コード構造と概念の理解に焦点を当てます。
次のステップでは、Mockito でスパイを作成するさまざまな方法を探求します。
このステップでは、Mockito でスパイを作成するためのさまざまなアプローチを探求します。Mockito.spy() メソッドと @Spy アノテーションを使用してスパイを作成する方法を学びます。
スパイを作成する最も直接的な方法は、Mockito.spy() メソッドを使用することです。このアプローチを示すテストメソッドを追加しましょう。
@Test
public void testSpyWithMockitoSpyMethod() {
// Create an ArrayList and a spy of it
ArrayList<Integer> realList = new ArrayList<>();
ArrayList<Integer> spyList = Mockito.spy(realList);
// Adding elements to the spy (real methods are called)
spyList.add(5);
spyList.add(10);
spyList.add(15);
// Verifying interactions
Mockito.verify(spyList).add(5);
Mockito.verify(spyList).add(10);
Mockito.verify(spyList).add(15);
// Verifying that elements were actually added to the list
assertEquals(3, spyList.size());
System.out.println("Spy Method Example - Spy List Content: " + spyList);
System.out.println("Spy Method Example - Spy List Size: " + spyList.size());
}スパイを作成するもう一つの方法は、@Spy アノテーションを使用することです。このアプローチは、スパイを自動的に初期化したい場合に特に役立ちます。次のコードを MockitoSpyDemo クラスに追加します。
// Declare a spy using annotation
@Spy
ArrayList<Integer> annotationSpyList = new ArrayList<>();
@Before
public void initSpies() {
// Initialize mocks and spies with annotations
MockitoAnnotations.initMocks(this);
}
@Test
public void testSpyWithAnnotation() {
// Adding elements to the spy
annotationSpyList.add(5);
annotationSpyList.add(10);
annotationSpyList.add(15);
// Verifying interactions
Mockito.verify(annotationSpyList).add(5);
Mockito.verify(annotationSpyList).add(10);
Mockito.verify(annotationSpyList).add(15);
// Verifying that elements were actually added to the list
assertEquals(3, annotationSpyList.size());
System.out.println("Annotation Spy Example - Spy List Content: " + annotationSpyList);
System.out.println("Annotation Spy Example - Spy List Size: " + annotationSpyList.size());
}どちらのアプローチもスパイを作成しますが、異なるユースケースがあります。
Mockito.spy() はより柔軟で、テストメソッドのどこでも使用できます。@Spy アノテーションは、多くのスパイがあり、それらを一度にすべて初期化したい場合に便利です。MockitoAnnotations.initMocks(this) メソッドは、すべてのアノテーション付きフィールドを初期化する役割を担います。実際のプロジェクトでは、この初期化を自動的に行うために @RunWith(MockitoJUnitRunner.class) を使用する場合があります。
更新されたコードをコンパイルしましょう。
cd ~/project
javac -cp lib/junit.jar:lib/mockito-core.jar:lib/byte-buddy.jar:lib/byte-buddy-agent.jar:lib/objenesis.jar:lib/hamcrest-core.jar MockitoSpyDemo.javaコードはエラーなしでコンパイルされるはずです。テストメソッドはこれで準備完了しましたが、前述のように、それらを自動的に実行するには JUnit ランナーが必要になります。
次のステップでは、スパイのデフォルトの動作をオーバーライドするために、スパイをスタブする方法を学びます。
このステップでは、スパイのデフォルトの動作をオーバーライドするためにスパイをスタブする方法と、Mockito を使用する際に発生する可能性のある例外を処理する方法を学びます。
スパイはデフォルトで実際のオブジェクトメソッドを使用しますが、テスト目的でこの動作を変更したい場合があります。これは、スパイの「スタブ化」と呼ばれます。スパイをスタブする方法を示すテストメソッドを追加しましょう。
@Test
public void testStubbingSpy() {
// Create a spy of ArrayList
ArrayList<Integer> spyList = Mockito.spy(new ArrayList<>());
// Add an element
spyList.add(5);
// Verify the element was added
Mockito.verify(spyList).add(5);
// By default, contains() should return true for element 5
assertTrue(spyList.contains(5));
System.out.println("Stubbing Example - Default behavior: spyList.contains(5) = " + spyList.contains(5));
// Stub the contains() method to always return false for the value 5
Mockito.doReturn(false).when(spyList).contains(5);
// Now contains() should return false, even though the element is in the list
assertFalse(spyList.contains(5));
System.out.println("Stubbing Example - After stubbing: spyList.contains(5) = " + spyList.contains(5));
// The element is still in the list (stubbing didn't change the list content)
assertEquals(1, spyList.size());
assertEquals(Integer.valueOf(5), spyList.get(0));
System.out.println("Stubbing Example - Spy List Content: " + spyList);
}スパイメソッドをスタブ化する際は、when() の代わりに doReturn()、doThrow()、doAnswer() などを推奨します。これは、スパイの場合、when().thenReturn() 構文がスタブ化中に実際のメソッドを呼び出す可能性があり、予期しない副作用を引き起こす可能性があるためです。
例：
// This might call the real get() method, causing issues if index 10 doesn't exist
Mockito.when(spyList.get(10)).thenReturn(99); // May throw IndexOutOfBoundsException
// This is the correct way to stub a spy
Mockito.doReturn(99).when(spyList).get(10); // Safe, doesn't call the real method通常のオブジェクト（モックまたはスパイではない）で Mockito の検証メソッドを使用しようとすると、NotAMockException が発生します。この例外を示すテストメソッドを追加しましょう。
@Test
public void testNotAMockException() {
try {
// Create a regular ArrayList (not a mock or spy)
ArrayList<Integer> regularList = new ArrayList<>();
regularList.add(5);
// Try to verify an interaction on a regular object
Mockito.verify(regularList).add(5);
fail("Expected NotAMockException was not thrown");
} catch (NotAMockException e) {
// Expected exception
System.out.println("NotAMockException Example - Caught expected exception: " + e.getMessage());
assertTrue(e.getMessage().contains("Argument passed to verify() is not a mock"));
}
}更新されたコードをコンパイルしましょう。
cd ~/project
javac -cp lib/junit.jar:lib/mockito-core.jar:lib/byte-buddy.jar:lib/byte-buddy-agent.jar:lib/objenesis.jar:lib/hamcrest-core.jar MockitoSpyDemo.javaコードはエラーなしでコンパイルされるはずです。このステップでは、スパイメソッドをスタブしてデフォルトの動作をオーバーライドする方法と、通常のオブジェクトで検証メソッドを使用する際に発生する NotAMockException を処理する方法を学びました。
次のステップでは、モックとスパイを比較して、その主な違いを理解します。
このステップでは、モックとスパイを直接比較して、その主な違いを理解します。この比較は、テストのニーズに適したツールを選択するのに役立ちます。
モックとスパイの違いを示すテストメソッドを追加しましょう。
@Test
public void testMockVsSpyDifference() {
// Create a mock and a spy of ArrayList
ArrayList<Integer> mockList = Mockito.mock(ArrayList.class);
ArrayList<Integer> spyList = Mockito.spy(new ArrayList<>());
// Add elements to both
mockList.add(1);
spyList.add(1);
// Verify interactions (both will pass)
Mockito.verify(mockList).add(1);
Mockito.verify(spyList).add(1);
// Check the size of both lists
System.out.println("Mock vs Spy - Mock List Size: " + mockList.size());
System.out.println("Mock vs Spy - Spy List Size: " + spyList.size());
// Mock returns default values (0 for size) unless stubbed
assertEquals(0, mockList.size());
// Spy uses real method implementation, so size is 1
assertEquals(1, spyList.size());
// Stub both to return size 100
Mockito.when(mockList.size()).thenReturn(100);
Mockito.when(spyList.size()).thenReturn(100);
// Both should now return 100 for size
assertEquals(100, mockList.size());
assertEquals(100, spyList.size());
System.out.println("Mock vs Spy (After Stubbing) - Mock List Size: " + mockList.size());
System.out.println("Mock vs Spy (After Stubbing) - Spy List Size: " + spyList.size());
}Mockito におけるモックとスパイの主な違いをまとめましょう。
メソッドの動作:
オブジェクトの状態:
作成:
Mockito.mock(ArrayList.class)）。Mockito.spy(new ArrayList<>())）。ユースケース:
スパイの一般的なユースケースである、複雑なオブジェクトの部分的なスタブ化を示すテストをもう一つ追加しましょう。
@Test
public void testWhenToUseSpy() {
// Create a complex data object that we want to partially mock
StringBuilder builder = new StringBuilder();
StringBuilder spyBuilder = Mockito.spy(builder);
// Use the real append method
spyBuilder.append("Hello");
spyBuilder.append(" World");
// Verify the real methods were called
Mockito.verify(spyBuilder).append("Hello");
Mockito.verify(spyBuilder).append(" World");
// The real methods modified the state
assertEquals("Hello World", spyBuilder.toString());
System.out.println("When to Use Spy - Content: " + spyBuilder.toString());
// Stub the toString() method to return something else
Mockito.when(spyBuilder.toString()).thenReturn("Stubbed String");
// Now toString() returns our stubbed value
assertEquals("Stubbed String", spyBuilder.toString());
System.out.println("When to Use Spy - After Stubbing toString(): " + spyBuilder.toString());
// But other methods still work normally
spyBuilder.append("!");
Mockito.verify(spyBuilder).append("!");
// toString() still returns our stubbed value
assertEquals("Stubbed String", spyBuilder.toString());
}更新されたコードをコンパイルしましょう。
cd ~/project
javac -cp lib/junit.jar:lib/mockito-core.jar:lib/byte-buddy.jar:lib/byte-buddy-agent.jar:lib/objenesis.jar:lib/hamcrest-core.jar MockitoSpyDemo.javaコードはエラーなしでコンパイルされるはずです。このステップでは、モックとスパイの主な違いと、それぞれを使用するタイミングを学びました。モックは元のオブジェクトの動作を完全に置き換えますが、スパイは元の動作を維持しつつ、必要に応じて特定のメソッドをオーバーライドできます。
この実験では、Java の単体テストのための強力な機能である Mockito のスパイの概念を探求しました。以下は、私たちがカバーした主なポイントです。
スパイの作成: Mockito.spy() メソッドと @Spy アノテーションの両方を使用してスパイを作成する方法を学びました。前者はより柔軟で、後者はスパイが多数ある場合に便利です。
スパイの動作: スパイはモックのようにメソッド呼び出しを追跡しますが、デフォルトでは実際のメソッドを実行します。この二重の性質により、インタラクションを検証する機能を維持しながら、実際のオブジェクトをテストするのに特に役立ちます。
スパイのスタブ化: doReturn()、doThrow()、およびその他のスタブ化メソッドを使用して、スパイメソッドのデフォルトの動作をオーバーライドする方法を発見しました。これにより、他の動作をそのまま維持しながら、特定の動作を制御できます。
例外処理: 通常のオブジェクトで Mockito の検証メソッドを使用しようとしたときに発生する NotAMockException を調べ、それを適切に処理する方法を検討しました。
Mock と Spy: モックとスパイを比較して、その主な違いを理解しました。モックは、元の動作をデフォルトまたはスタブされた応答で完全に置き換えますが、スパイは元の動作を維持しつつ、特定のメソッドをオーバーライドできます。
スパイは、Mockito の強力なツールであり、モックの完全な制御と実際のオブジェクトのリアリズムのバランスを提供します。これは、特に次のような場合に役立ちます。
スパイをいつ、どのように使用するかを理解することで、Java アプリケーションのより効果的で保守性の高い単体テストを作成できます。
