Easymock-quick-guide
提供：Dev Guides
EasyMock-概要
モッキングとは何ですか？
モッキングは、クラスの機能を単独でテストする方法です。 モックでは、機能をテストするためにデータベース接続やプロパティファイルの読み取りやファイルサーバーの読み取りは必要ありません。 モックオブジェクトは、実際のサービスのモックを行います。 モックオブジェクトは、渡されたダミー入力に対応するダミーデータを返します。
EasyMock
EasyMockは、モックオブジェクトのシームレスな作成を容易にします。 Java Reflectionを使用して、特定のインターフェイスのモックオブジェクトを作成します。 モックオブジェクトは、実際の実装のプロキシにすぎません。 株式の価格の詳細を返す株式サービスの場合を考えてみましょう。 開発中、実際のストックサービスを使用してリアルタイムデータを取得することはできません。 そのため、ストックサービスのダミー実装が必要です。 EasyMockは、その名前が示すとおり、非常に簡単に同じことができます。
EasyMockの利点
- 手書きなし –自分でモックオブジェクトを書く必要はありません。
- リファクタリングセーフ –インターフェイスメソッド名の変更やパラメータの並べ替えは、実行時にMocksが作成されるため、テストコードを壊しません。
- 戻り値のサポート –戻り値をサポートします。
- 例外サポート –例外をサポートします。
- 順序チェックのサポート –メソッド呼び出しの順序のチェックをサポートします。
- 注釈のサポート –注釈を使用したモックの作成をサポートします。
次のコードスニペットを考えてください。
package com.finddevguides.mock;
import java.util.ArrayList;
import java.util.List;
import org.EasyMock.EasyMock;
public class PortfolioTester {
public static void main(String[] args){
//Create a portfolio object which is to be tested
Portfolio portfolio = new Portfolio();
//Creates a list of stocks to be added to the portfolio
List stocks = new ArrayList();
Stock googleStock = new Stock("1","Google", 10);
Stock microsoftStock = new Stock("2","Microsoft",100);
stocks.add(googleStock);
stocks.add(microsoftStock);
//Create the mock object of stock service
StockService stockServiceMock = EasyMock.createMock(StockService.class);
//mock the behavior of stock service to return the value of various stocks
EasyMock.expect(stockServiceMock.getPrice(googleStock)).andReturn(50.00);
EasyMock.expect(stockServiceMock.getPrice(microsoftStock)).andReturn(1000.00);
EasyMock.replay(stockServiceMock);
//add stocks to the portfolio
portfolio.setStocks(stocks);
//set the stockService to the portfolio
portfolio.setStockService(stockServiceMock);
double marketValue = portfolio.getMarketValue();
//verify the market value to be
//10*50.00 + 100* 1000.00 = 500.00 + 100000.00 = 100500
System.out.println("Market value of the portfolio: "+ marketValue);
}
}上記のプログラムの重要な概念を理解しましょう。 完全なコードは、 _ First Application_ の章で入手できます。
- ポートフォリオ –株式のリストを保持し、株価と在庫量を使用して計算された市場価値を取得するオブジェクト。
- ストック – ID、名前、数量などのストックの詳細を保持するオブジェクト。
- StockService –株式サービスは、株式の現在の価格を返します。
- * EasyMock.createMock（…）* – EasyMockはストックサービスのモックを作成しました。
- * EasyMock.expect（…）。andReturn（…）* – stockServiceインターフェイスのgetPriceメソッドのモック実装。 googleStockの場合、価格として50.00を返します。
- * EasyMock.replay（…）* – EasyMockは、テストに使用できるようにMockオブジェクトの準備を整えます。
- * portfolio.setStocks（…）* –現在、ポートフォリオには2つの株式のリストが含まれています。
- * portfolio.setStockService（…）*-stockService Mockオブジェクトをポートフォリオに割り当てます。
- * portfolio.getMarketValue（）* –ポートフォリオは、模擬株式サービスを使用して、株式に基づいて市場価値を返します。
EasyMock-環境設定
EasyMockはJavaのフレームワークであるため、最初の要件はマシンにJDKをインストールすることです。
システム要件
| JDK | 1.5 or above. |
| Memory | no minimum requirement. |
| Disk Space | no minimum requirement. |
| Operating System | no minimum requirement. |
ステップ1：マシンでのJavaインストールの検証
コンソールを開き、次の java コマンドを実行します。
| OS | Task | Command |
|---|---|---|
| Windows | Open Command Console | c:\> java -version |
| Linux | Open Command Terminal | $ java -version |
| Mac | Open Terminal | machine:~ joseph$ java -version |
すべてのオペレーティングシステムの出力を確認しましょう。
| OS | Output |
|---|---|
| Windows |
java version "1.6.0_21" Java（TM）SEランタイム環境（ビルド1.6.0_21-b07） Java HotSpot（TM）Client VM（ビルド17.0-b17、混合モード、共有） |
| Linux |
java version "1.6.0_21" Java（TM）SEランタイム環境（ビルド1.6.0_21-b07） Java HotSpot（TM）Client VM（ビルド17.0-b17、混合モード、共有） |
| Mac |
java version "1.6.0_21" Java（TM）SEランタイム環境（ビルド1.6.0_21-b07） Java HotSpot（TM）64ビットサーバーVM（ビルド17.0-b17、混合モード、共有） |
Javaをインストールしていない場合、Java Software Development Kit（SDK）をインストールするにはhttp://www.oracle.com/technetwork/java/javase/downloads/indexl [ここをクリック]
このチュートリアルでは、システムにJava 1.6.0_21がインストールされていると想定しています。
ステップ2：JAVA環境の設定
*JAVA_HOME* 環境変数を設定して、Javaがマシンにインストールされているベースディレクトリの場所を指すようにします。 例えば、| OS | Output |
|---|---|
| Windows | Set the environment variable JAVA_HOME to C:\Program Files\Java\jdk1.6.0_21 |
| Linux | export JAVA_HOME=/usr/local/java-current |
| Mac | export JAVA_HOME=/Library/Java/Home |
Javaコンパイラの場所をシステムパスに追加します。
| OS | Output |
|---|---|
| Windows | Append the string ;C:\Program Files\Java\jdk1.6.0_21\bin to the end of the system variable, Path. |
| Linux | export PATH=$PATH:$JAVA_HOME/bin/ |
| Mac | not required |
上記の説明に従って、コマンド java -version を使用してJavaインストールを確認します。
- ステップ3：EasyMock Archive *をダウンロードする
EasyMockの最新バージョンをダウンロードするにはhttp://sourceforge.net/projects/easymock/files/EasyMock/3.2/easymock-3.2.zip/download [ここをクリックしてください。]
Cドライブにzipフォルダーを保存します。C：\> EasyMockとしましょう。
| OS | Archive name |
|---|---|
| Windows | easymock-3.2.zip |
| Linux | easymock-3.2.zip |
| Mac | easymock-3.2.zip |
ステップ4：EasyMock依存関係のダウンロード
[[1]] jarファイルの最新バージョンをダウンロードし、C：\> EasyMockフォルダーにコピーします。 このチュートリアルを書いている時点では、最新バージョンは3.1でした。
[[2]] zipファイルをダウンロードし、C：\> EasyMockフォルダーにコピーします。 このチュートリアルを書いている時点では、最新バージョンは2.1でした。 objenesis-2.1.jarをC：\> EasyMockフォルダーに抽出します
ステップ5：EasyMock環境の設定
*EasyMock_HOME* 環境変数を設定して、EasyMockと依存関係jarがマシンに保存されているベースディレクトリの場所を指すようにします。 次の表は、easymock-3.2.jar、cglib-3.1.jar、およびobjenesis-2.1.jarをC：\> EasyMockフォルダーに抽出したと仮定して、さまざまなオペレーティングシステムで環境変数を設定する方法を示しています。| OS | Output |
|---|---|
| Windows | Set the environment variable EasyMock_HOME to C:\EasyMock |
| Linux | export EasyMock_HOME=/usr/local/EasyMock |
| Mac | export EasyMock_HOME=/Library/EasyMock |
ステップ6：CLASSPATH変数の設定
*CLASSPATH* 環境変数を設定して、EasyMockおよび依存関係jarが保管されている場所を指します。 次の表は、さまざまなオペレーティングシステムでCLASSPATH変数を設定する方法を示しています。| OS | Output |
|---|---|
| Windows | Set the environment variable CLASSPATH to %CLASSPATH%;%EasyMock_HOME%\easymock-3.2.jar;%EasyMock_HOME%\cglib-3.1.jar;%EasyMock_HOME%\objenesis-2.1.jar;.; |
| Linux | export CLASSPATH=$CLASSPATH:$EasyMock_HOME/easymock-3.2.jar:$EasyMock_HOME/cglib-3.1.jar:$EasyMock_HOME/objenesis-2.1.jar:. |
| Mac | export CLASSPATH=$CLASSPATH:$EasyMock_HOME/easymock-3.2.jar:$EasyMock_HOME/cglib-3.1.jar:$EasyMock_HOME/objenesis-2.1.jar:. |
ステップ7：JUnitアーカイブのダウンロード
GithubからJUnit jarファイルの最新バージョンをダウンロードします。 C：\> Junitの場所にフォルダーを保存します。
| OS | Archive name |
|---|---|
| Windows | junit4.11.jar, hamcrest-core-1.2.1.jar |
| Linux | junit4.11.jar, hamcrest-core-1.2.1.jar |
| Mac | junit4.11.jar, hamcrest-core-1.2.1.jar |
ステップ8：JUnit環境の設定
*JUNIT_HOME* 環境変数を設定して、マシン上のJUnit jarが格納されているベースディレクトリの場所を指すようにします。 次の表は、C：\> Junitにjunit4.11.jarおよびhamcrest-core-1.2.1.jarを保存したと仮定して、異なるオペレーティングシステムでこの環境変数を設定する方法を示しています。| OS | Output |
|---|---|
| Windows | Set the environment variable JUNIT_HOME to C:\JUNIT |
| Linux | export JUNIT_HOME=/usr/local/JUNIT |
| Mac | export JUNIT_HOME=/Library/JUNIT |
ステップ9：CLASSPATH変数の設定
JUNIT jarの場所を指すようにCLASSPATH環境変数を設定します。 次の表は、さまざまなオペレーティングシステムでどのように実行されるかを示しています。
| OS | Output |
|---|---|
| Windows | Set the environment variable CLASSPATH to %CLASSPATH%;%JUNIT_HOME%\junit4.11.jar;%JUNIT_HOME% \hamcrest-core-1.2.1.jar;.; |
| Linux | export CLASSPATH=$CLASSPATH:$JUNIT_HOME/junit4.11.jar:$JUNIT_HOME/hamcrest-core-1.2.1.jar:. |
| Mac | export CLASSPATH=$CLASSPATH:$JUNIT_HOME/junit4.11.jar:$JUNIT_HOME/hamcrest-core-1.2.1.jar:. |
EasyMock-最初のアプリケーション
EasyMock Frameworkの詳細に入る前に、動作中のアプリケーションを見てみましょう。 この例では、一部の株式のダミー価格を取得するためにストックサービスのモックを作成し、Portfolioという名前のJavaクラスを単体テストしました。
このプロセスについては、ステップごとに説明します。
ステップ1：Stockを表すJAVAクラスを作成します
ファイル：Stock.java
public class Stock {
private String stockId;
private String name;
private int quantity;
public Stock(String stockId, String name, int quantity){
this.stockId = stockId;
this.name = name;
this.quantity = quantity;
}
public String getStockId() {
return stockId;
}
public void setStockId(String stockId) {
this.stockId = stockId;
}
public int getQuantity() {
return quantity;
}
public String getTicker() {
return name;
}
}ステップ2：株価を取得するインターフェースStockServiceを作成する
File：StockService.java
public interface StockService {
public double getPrice(Stock stock);
}- ステップ3：クライアントのポートフォリオを表すクラスポートフォリオを作成します *
ファイル：Portfolio.java
import java.util.List;
public class Portfolio {
private StockService stockService;
private List stocks;
public StockService getStockService() {
return stockService;
}
public void setStockService(StockService stockService) {
this.stockService = stockService;
}
public List getStocks() {
return stocks;
}
public void setStocks(List stocks) {
this.stocks = stocks;
}
public double getMarketValue(){
double marketValue = 0.0;
for(Stock stock:stocks){
marketValue += stockService.getPrice(stock)* stock.getQuantity();
}
return marketValue;
}
}ステップ4：ポートフォリオクラスをテストする
Stockserviceのモックを注入して、Portfolioクラスをテストしましょう。 モックはEasyMockによって作成されます。
ファイル：PortfolioTester.java
import java.util.ArrayList;
import java.util.List;
import org.easymock.EasyMock;
public class PortfolioTester {
Portfolio portfolio;
StockService stockService;
public static void main(String[] args){
PortfolioTester tester = new PortfolioTester();
tester.setUp();
System.out.println(tester.testMarketValue()?"pass":"fail");
}
public void setUp(){
//Create a portfolio object which is to be tested
portfolio = new Portfolio();
//Create the mock object of stock service
stockService = EasyMock.createMock(StockService.class);
//set the stockService to the portfolio
portfolio.setStockService(stockService);
}
public boolean testMarketValue(){
//Creates a list of stocks to be added to the portfolio
List<Stock> stocks = new ArrayList<Stock>();
Stock googleStock = new Stock("1","Google", 10);
Stock microsoftStock = new Stock("2","Microsoft",100);
stocks.add(googleStock);
stocks.add(microsoftStock);
//add stocks to the portfolio
portfolio.setStocks(stocks);
//mock the behavior of stock service to return the value of various stocks
EasyMock.expect(stockService.getPrice(googleStock)).andReturn(50.00);
EasyMock.expect(stockService.getPrice(microsoftStock)).andReturn(1000.00);
//activate the mock
EasyMock.replay(stockService);
double marketValue = portfolio.getMarketValue();
return marketValue == 100500.0;
}
}ステップ5：結果を確認する
次のように javac コンパイラを使用してクラスをコンパイルします。
C:\EasyMock_WORKSPACE>javac Stock.java StockService.java Portfolio.java PortfolioTester.java次に、PortfolioTesterを実行して結果を確認します。
C:\EasyMock_WORKSPACE>java PortfolioTester出力を確認する
passEasyMock-JUnit統合
この章では、JUnitとEasyMockを統合する方法を学びます。 ここでは、CalculatorServiceを使用して加算、減算、乗算、除算などの基本的な数学演算を実行する数学アプリケーションを作成します。 EasyMockを使用して、CalculatorServiceのダミー実装をモックします。 さらに、アノテーションを広範囲に使用して、JUnitとEasyMockの両方との互換性を紹介しました。
このプロセスについては、ステップごとに説明します。
ステップ1：数学関数を提供するCalculatorServiceというインターフェイスを作成します
File：CalculatorService.java
public interface CalculatorService {
public double add(double input1, double input2);
public double subtract(double input1, double input2);
public double multiply(double input1, double input2);
public double divide(double input1, double input2);
}ステップ2：MathApplicationを表すJAVAクラスを作成します
File：MathApplication.java
public class MathApplication {
private CalculatorService calcService;
public void setCalculatorService(CalculatorService calcService){
this.calcService = calcService;
}
public double add(double input1, double input2){
return calcService.add(input1, input2);
}
public double subtract(double input1, double input2){
return calcService.subtract(input1, input2);
}
public double multiply(double input1, double input2){
return calcService.multiply(input1, input2);
}
public double divide(double input1, double input2){
return calcService.divide(input1, input2);
}
}ステップ3：MathApplicationクラスをテストする
calculatorServiceのモックを注入して、MathApplicationクラスをテストしましょう。 モックはEasyMockによって作成されます。
ファイル：MathApplicationTester.java
import org.easymock.EasyMock;
import org.easymock.EasyMockRunner;
import org.easymock.Mock;
import org.easymock.TestSubject;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
//@RunWith attaches a runner with the test class to initialize the test data
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
//@TestSubject annotation is used to identify class which is going to use the mock object
@TestSubject
MathApplication mathApplication = new MathApplication();
//@Mock annotation is used to create the mock object to be injected
@Mock
CalculatorService calcService;
@Test
public void testAdd(){
//add the behavior of calc service to add two numbers
EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);
//activate the mock
EasyMock.replay(calcService);
//test the add functionality
Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);
}
}ステップ4：テストケースに実行するクラスを作成します
*C：\> EasyMock_WORKSPACE* にTestRunnerという名前のJavaクラスファイルを作成して、テストケースを実行します。ファイル：TestRunner.java
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(MathApplicationTester.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}ステップ5：結果を確認する
次のように javac コンパイラを使用してクラスをコンパイルします。
C:\EasyMock_WORKSPACE>javac CalculatorService.java MathApplication.java MathApplicationTester.java TestRunner.java次に、テストランナーを実行して結果を確認します。
C:\EasyMock_WORKSPACE>java TestRunner出力を確認します。
trueJUnitの詳細については、チュートリアルポイントのJUnitチュートリアルを参照してください。
EasyMock-動作の追加
EasyMockは、* expect（）メソッドと expectLassCall（）*メソッドを使用して、モックオブジェクトに機能を追加します。 次のコードスニペットをご覧ください。
//add the behavior of calc service to add two numbers
EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);ここでは、EasyMockにcalcServiceのaddメソッドに10と20を追加し、その結果30.00の値を返すように動作するように指示しました。
この時点で、モックは単に動作を記録しましたが、モックオブジェクトとして機能していません。 リプレイを呼び出した後、期待どおりに動作します。
//add the behavior of calc service to add two numbers
EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);
//activate the mock
//EasyMock.replay(calcService);EasyMock.Replay（）を使用しない例
ステップ1：数学関数を提供するCalculatorServiceというインターフェイスを作成します
File：CalculatorService.java
public interface CalculatorService {
public double add(double input1, double input2);
public double subtract(double input1, double input2);
public double multiply(double input1, double input2);
public double divide(double input1, double input2);
}ステップ2：MathApplicationを表すJAVAクラスを作成します
File：MathApplication.java
public class MathApplication {
private CalculatorService calcService;
public void setCalculatorService(CalculatorService calcService){
this.calcService = calcService;
}
public double add(double input1, double input2){
return calcService.add(input1, input2);
}
public double subtract(double input1, double input2){
return calcService.subtract(input1, input2);
}
public double multiply(double input1, double input2){
return calcService.multiply(input1, input2);
}
public double divide(double input1, double input2){
return calcService.divide(input1, input2);
}
}ステップ3：MathApplicationクラスをテストする
calculatorServiceのモックを注入して、MathApplicationクラスをテストしましょう。 モックはEasyMockによって作成されます。
ファイル：MathApplicationTester.java
import org.easymock.EasyMock;
import org.easymock.EasyMockRunner;
import org.easymock.Mock;
import org.easymock.TestSubject;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
//@RunWith attaches a runner with the test class to initialize the test data
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
//@TestSubject annotation is used to identify the class which is going to use the mock object
@TestSubject
MathApplication mathApplication = new MathApplication();
//@Mock annotation is used to create the mock object to be injected
@Mock
CalculatorService calcService;
@Test
public void testAdd(){
//add the behavior of calc service to add two numbers
EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);
//activate the mock
//EasyMock.replay(calcService);
//test the add functionality
Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);
}
}ステップ4：テストケースを実行する
*C：\> EasyMock_WORKSPACE* にTestRunnerという名前のJavaクラスファイルを作成して、テストケースを実行します。ファイル：TestRunner.java
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(MathApplicationTester.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}ステップ5：結果を確認する
次のように javac コンパイラを使用してクラスをコンパイルします。
C:\EasyMock_WORKSPACE>javac Calculator Service.java Math Application.java Math Application Tester.java Test Runner.java次に、テストランナーを実行して結果を確認します。
C:\EasyMock_WORKSPACE>java TestRunner出力を確認します。
testAdd(MathApplicationTester): expected:<0.0> but was:<30.0>
falseEasyMock.Replay（）を使用した例
ステップ1：数学関数を提供するCalculatorServiceというインターフェイスを作成します。
File：CalculatorService.java
public interface CalculatorService {
public double add(double input1, double input2);
public double subtract(double input1, double input2);
public double multiply(double input1, double input2);
public double divide(double input1, double input2);
}ステップ2：MathApplicationを表すJAVAクラスを作成します。
File：MathApplication.java
public class MathApplication {
private CalculatorService calcService;
public void setCalculatorService(CalculatorService calcService){
this.calcService = calcService;
}
public double add(double input1, double input2){
return calcService.add(input1, input2);
}
public double subtract(double input1, double input2){
return calcService.subtract(input1, input2);
}
public double multiply(double input1, double input2){
return calcService.multiply(input1, input2);
}
public double divide(double input1, double input2){
return calcService.divide(input1, input2);
}
}ステップ3：MathApplicationクラスをテストする
calculatorServiceのモックを注入して、MathApplicationクラスをテストしましょう。 モックはEasyMockによって作成されます。
ファイル：MathApplicationTester.java
import org.easymock.EasyMock;
import org.easymock.EasyMockRunner;
import org.easymock.Mock;
import org.easymock.TestSubject;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
//@RunWith attaches a runner with the test class to initialize the test data
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
//@TestSubject annotation is used to identify class which is going to use the mock object
@TestSubject
MathApplication mathApplication = new MathApplication();
//@Mock annotation is used to create the mock object to be injected
@Mock
CalculatorService calcService;
@Test
public void testAdd(){
//add the behavior of calc service to add two numbers
EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);
//activate the mock
EasyMock.replay(calcService);
//test the add functionality
Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);
}
}ステップ4：テストケースを実行する
*C：\> EasyMock_WORKSPACE* にTestRunnerという名前のJavaクラスファイルを作成して、テストケースを実行します。ファイル：TestRunner.java
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(MathApplicationTester.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}ステップ5：結果を確認する
次のように javac コンパイラを使用してクラスをコンパイルします。
C:\EasyMock_WORKSPACE>javac Calculator Service.java Math Application.java Math Application Tester.java Test Runner.java次に、テストランナーを実行して結果を確認します。
C:\EasyMock_WORKSPACE>java TestRunner出力を確認します。
trueEasyMock-動作の検証
EasyMockは、モックが使用されているかどうかを確認できます。 * verify（）*メソッドを使用して行われます。 次のコードスニペットをご覧ください。
//activate the mock
EasyMock.replay(calcService);
//test the add functionality
Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);
//verify call to calcService is made or not
EasyMock.verify(calcService);EasyMock.Verify（）を使用しない例
ステップ1：数学関数を提供するCalculatorServiceというインターフェイスを作成します
File：CalculatorService.java
public interface CalculatorService {
public double add(double input1, double input2);
public double subtract(double input1, double input2);
public double multiply(double input1, double input2);
public double divide(double input1, double input2);
}ステップ2：MathApplicationを表すJAVAクラスを作成します
File：MathApplication.java
public class MathApplication {
private CalculatorService calcService;
public void setCalculatorService(CalculatorService calcService){
this.calcService = calcService;
}
public double add(double input1, double input2){
//return calcService.add(input1, input2);
return input1 + input2;
}
public double subtract(double input1, double input2){
return calcService.subtract(input1, input2);
}
public double multiply(double input1, double input2){
return calcService.multiply(input1, input2);
}
public double divide(double input1, double input2){
return calcService.divide(input1, input2);
}
}ステップ3：MathApplicationクラスをテストする
calculatorServiceのモックを注入して、MathApplicationクラスをテストしましょう。 モックはEasyMockによって作成されます。
ファイル：MathApplicationTester.java
import org.easymock.EasyMock;
import org.easymock.EasyMockRunner;
import org.easymock.Mock;
import org.easymock.TestSubject;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
//@RunWith attaches a runner with the test class to initialize the test data
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
//@TestSubject annotation is used to identify class which is going to
use the mock object
@TestSubject
MathApplication mathApplication = new MathApplication();
//@Mock annotation is used to create the mock object to be injected
@Mock
CalculatorService calcService;
@Test
public void testAdd(){
//add the behavior of calc service to add two numbers
EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);
//activate the mock
EasyMock.replay(calcService);
//test the add functionality
Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);
//verify call to calcService is made or not
//EasyMock.verify(calcService);
}
}ステップ4：テストケースを実行する
*C：\> EasyMock_WORKSPACE* にTestRunnerという名前のJavaクラスファイルを作成して、テストケースを実行します。ファイル：TestRunner.java
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(MathApplicationTester.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}ステップ5：結果を確認する
次のように javac コンパイラを使用してクラスをコンパイルします。
C:\EasyMock_WORKSPACE>javac Calculator Service.java Math Application.java Math Application Tester.java Test Runner.javaテストランナーを実行して結果を確認します
C:\EasyMock_WORKSPACE>java TestRunner出力を確認します。
trueEasyMock.Verify（）を使用した例
ステップ1：数学関数を提供するインターフェースCalculatorServiceを作成します
File：CalculatorService.java
public interface CalculatorService {
public double add(double input1, double input2);
public double subtract(double input1, double input2);
public double multiply(double input1, double input2);
public double divide(double input1, double input2);
}ステップ2：MathApplicationを表すJAVAクラスを作成します
File：MathApplication.java
public class MathApplication {
private CalculatorService calcService;
public void setCalculatorService(CalculatorService calcService){
this.calcService = calcService;
}
public double add(double input1, double input2){
//return calcService.add(input1, input2);
return input1 + input2;
}
public double subtract(double input1, double input2){
return calcService.subtract(input1, input2);
}
public double multiply(double input1, double input2){
return calcService.multiply(input1, input2);
}
public double divide(double input1, double input2){
return calcService.divide(input1, input2);
}
}ステップ3：MathApplicationクラスをテストする
calculatorServiceのモックを注入して、MathApplicationクラスをテストしましょう。 モックはEasyMockによって作成されます。
ファイル：MathApplicationTester.java
import org.easymock.EasyMock;
import org.easymock.EasyMockRunner;
import org.easymock.Mock;
import org.easymock.TestSubject;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
//@RunWith attaches a runner with the test class to initialize the test data
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
//@TestSubject annotation is used to identify class which is going to use the mock object
@TestSubject
MathApplication mathApplication = new MathApplication();
//@Mock annotation is used to create the mock object to be injected
@Mock
CalculatorService calcService;
@Test
public void testAdd(){
//add the behavior of calc service to add two numbers
EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);
//activate the mock
EasyMock.replay(calcService);
//test the add functionality
Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);
//verify call to calcService is made or not
EasyMock.verify(calcService);
}
}ステップ4：テストケースを実行する
*C：\> EasyMock_WORKSPACE* にTestRunnerという名前のJavaクラスファイルを作成して、テストケースを実行します。ファイル：TestRunner.java
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(MathApplicationTester.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}ステップ5：結果を確認する
次のように javac コンパイラを使用してクラスをコンパイルします。
C:\EasyMock_WORKSPACE>javac Calculator Service.java Math Application.java Math Application Tester.java Test Runner.java次に、テストランナーを実行して結果を確認します。
C:\EasyMock_WORKSPACE>java TestRunner出力を確認します。
testAdd(MathApplicationTester):
Expectation failure on verify:
CalculatorService.add(10.0, 20.0): expected: 1, actual: 0
falseEasyMock-コールを期待する
EasyMockは、特定のメソッドで実行できる呼び出しの数を特別にチェックします。 MathApplicationがCalculatorService.serviceUsed（）メソッドを1回だけ呼び出す必要があり、CalculatorService.serviceUsed（）を複数回呼び出すことができないと仮定します。
//add the behavior of calc service to add two numbers and serviceUsed.
EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);
calcService.serviceUsed();
//limit the method call to 1, no less and no more calls are allowed
EasyMock.expectLastCall().times(1);次のようにCalculatorServiceインターフェースを作成します。
File：CalculatorService.java
public interface CalculatorService {
public double add(double input1, double input2);
public double subtract(double input1, double input2);
public double multiply(double input1, double input2);
public double divide(double input1, double input2);
public void serviceUsed();
}calcService.serviceUsed（）が1回呼び出された例
ステップ1：数学関数を提供するCalculatorServiceというインターフェイスを作成します
File：CalculatorService.java
public interface CalculatorService {
public double add(double input1, double input2);
public double subtract(double input1, double input2);
public double multiply(double input1, double input2);
public double divide(double input1, double input2);
public void serviceUsed();
}ステップ2：MathApplicationを表すJAVAクラスを作成します
File：MathApplication.java
public class MathApplication {
private CalculatorService calcService;
public void setCalculatorService(CalculatorService calcService){
this.calcService = calcService;
}
public double add(double input1, double input2){
calcService.serviceUsed();
return calcService.add(input1, input2);
}
public double subtract(double input1, double input2){
return calcService.subtract(input1, input2);
}
public double multiply(double input1, double input2){
return calcService.multiply(input1, input2);
}
public double divide(double input1, double input2){
return calcService.divide(input1, input2);
}
}ステップ3：MathApplicationクラスをテストする
calculatorServiceのモックを注入して、MathApplicationクラスをテストしましょう。 モックはEasyMockによって作成されます。
ファイル：MathApplicationTester.java
import org.easymock.EasyMock;
import org.easymock.EasyMockRunner;
import org.easymock.Mock;
import org.easymock.TestSubject;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
//@RunWith attaches a runner with the test class to initialize the test data
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
//@TestSubject annotation is used to identify class which is going to use the mock object
@TestSubject
MathApplication mathApplication = new MathApplication();
//@Mock annotation is used to create the mock object to be injected
@Mock
CalculatorService calcService;
@Test
public void testAdd(){
//add the behavior of calc service to add two numbers
EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);
calcService.serviceUsed();
EasyMock.expectLastCall().times(1);
//activate the mock
EasyMock.replay(calcService);
//test the add functionality
Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);
//verify call to calcService is made or not
EasyMock.verify(calcService);
}
}ステップ4：テストケースを実行する
*C：\> EasyMock_WORKSPACE* にTestRunnerという名前のJavaクラスファイルを作成して、テストケースを実行します。ファイル：TestRunner.java
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(MathApplicationTester.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}ステップ5：結果を確認する
次のように javac コンパイラを使用してクラスをコンパイルします。
C:\EasyMock_WORKSPACE>javac Calculator Service.java Math Application.java Math Application Tester.java Test Runner.java次に、テストランナーを実行して結果を確認します。
C:\EasyMock_WORKSPACE>java TestRunner出力を確認します。
true2回呼び出されるcalcService.serviceUsed（）の例
ステップ1：数学関数を提供するインターフェースCalculatorServiceを作成します。
File：CalculatorService.java
public interface CalculatorService {
public double add(double input1, double input2);
public double subtract(double input1, double input2);
public double multiply(double input1, double input2);
public double divide(double input1, double input2);
public void serviceUsed();
}ステップ2：MathApplicationを表すJAVAクラスを作成します。
File：MathApplication.java
public class MathApplication {
private CalculatorService calcService;
public void setCalculatorService(CalculatorService calcService){
this.calcService = calcService;
}
public double add(double input1, double input2){
calcService.serviceUsed();
calcService.serviceUsed();
return calcService.add(input1, input2);
}
public double subtract(double input1, double input2){
return calcService.subtract(input1, input2);
}
public double multiply(double input1, double input2){
return calcService.multiply(input1, input2);
}
public double divide(double input1, double input2){
return calcService.divide(input1, input2);
}
}ステップ3：MathApplicationクラスをテストする
calculatorServiceのモックを注入して、MathApplicationクラスをテストしましょう。 モックはEasyMockによって作成されます。
ファイル：MathApplicationTester.java
import org.easymock.EasyMock;
import org.easymock.EasyMockRunner;
import org.easymock.Mock;
import org.easymock.TestSubject;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
//@RunWith attaches a runner with the test class to initialize the test data
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
//@TestSubject annotation is used to identify class which is going to use the mock object
@TestSubject
MathApplication mathApplication = new MathApplication();
//@Mock annotation is used to create the mock object to be injected
@Mock
CalculatorService calcService;
@Test
public void testAdd(){
//add the behavior of calc service to add two numbers
EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);
calcService.serviceUsed();
EasyMock.expectLastCall().times(1);
//activate the mock
EasyMock.replay(calcService);
//test the add functionality
Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);
//verify call to calcService is made or not
EasyMock.verify(calcService);
}
}ステップ4：テストケースを実行する<
テストケースを実行するには、* C：\> EasyMock_WORKSPACE *にTestRunnerという名前のJavaクラスファイルを作成します。
ファイル：TestRunner.java
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(MathApplicationTester.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}ステップ5：結果を確認する
次のように javac コンパイラを使用してクラスをコンパイルします。
C:\EasyMock_WORKSPACE>javac CalculatorService.java MathApplication.java MathApplicationTester.java TestRunner.java次に、テストランナーを実行して結果を確認します。
C:\EasyMock_WORKSPACE>java TestRunner出力を確認します。
testAdd(com.finddevguides.mock.MathApplicationTester):
Unexpected method call CalculatorService.serviceUsed():
CalculatorService.add(10.0, 20.0): expected: 1, actual: 0
CalculatorService.serviceUsed(): expected: 1, actual: 2
falsecalcService.serviceUsed（）を呼び出さない例
ステップ1：数学関数を提供するインターフェースCalculator Serviceを作成します
File：CalculatorService.java
public interface CalculatorService {
public double add(double input1, double input2);
public double subtract(double input1, double input2);
public double multiply(double input1, double input2);
public double divide(double input1, double input2);
public void serviceUsed();
}ステップ2：MathApplicationを表すJAVAクラスを作成します
File：MathApplication.java
public class MathApplication {
private CalculatorService calcService;
public void setCalculatorService(CalculatorService calcService){
this.calcService = calcService;
}
public double add(double input1, double input2){
return calcService.add(input1, input2);
}
public double subtract(double input1, double input2){
return calcService.subtract(input1, input2);
}
public double multiply(double input1, double input2){
return calcService.multiply(input1, input2);
}
public double divide(double input1, double input2){
return calcService.divide(input1, input2);
}
}ステップ3：MathApplicationクラスをテストする
calculatorServiceのモックを注入して、MathApplicationクラスをテストしましょう。 モックはEasyMockによって作成されます。
ファイル：MathApplicationTester.java
import org.easymock.EasyMock;
import org.easymock.EasyMockRunner;
import org.easymock.Mock;
import org.easymock.TestSubject;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
//@RunWith attaches a runner with the test class to initialize the test data
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
//@TestSubject annotation is used to identify class which is going to use the mock object
@TestSubject
MathApplication mathApplication = new MathApplication();
//@Mock annotation is used to create the mock object to be injected
@Mock
CalculatorService calcService;
@Test
public void testAdd(){
//add the behavior of calc service to add two numbers
EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);
calcService.serviceUsed();
EasyMock.expectLastCall().times(1);
//activate the mock
EasyMock.replay(calcService);
//test the add functionality
Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);
//verify call to calcService is made or not
EasyMock.verify(calcService);
}
}ステップ4：テストケースを実行する
*C：\> EasyMock_WORKSPACE* にTestRunnerという名前のJavaクラスファイルを作成して、テストケースを実行します。ファイル：TestRunner.java
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(MathApplicationTester.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}ステップ5：結果を確認する
次のように javac コンパイラを使用してクラスをコンパイルします。
C:\EasyMock_WORKSPACE>javac Calculator Service.java Math Application.java Math Application Tester.java Test Runner.java次に、テストランナーを実行して結果を確認します。
C:\EasyMock_WORKSPACE>java TestRunner出力を確認します。
testAdd(com.finddevguides.mock.MathApplicationTester):
Expectation failure on verify:
CalculatorService.serviceUsed(): expected: 1, actual: 0
falseEasyMock-さまざまな通話
EasyMockは、予想されるコールカウントを変更するために、次の追加メソッドを提供します。
- * times（int min、int max）* – minとmaxの間の呼び出しを想定しています。
- * atLeastOnce（）* –少なくとも1つの呼び出しが必要です。
- * anyTimes（）* –呼び出しの数に制限はありません。
時間（最小、最大）の例
ステップ1：数学関数を提供するインターフェースCalculatorServiceを作成します
File：CalculatorService.java
public interface CalculatorService {
public double add(double input1, double input2);
public double subtract(double input1, double input2);
public double multiply(double input1, double input2);
public double divide(double input1, double input2);
public void serviceUsed();
}ステップ2：MathApplicationを表すJAVAクラスを作成します
File：MathApplication.java
public class MathApplication {
private CalculatorService calcService;
public void setCalculatorService(CalculatorService calcService){
this.calcService = calcService;
}
public double add(double input1, double input2){
calcService.serviceUsed();
calcService.serviceUsed();
calcService.serviceUsed();
return calcService.add(input1, input2);
}
public double subtract(double input1, double input2){
return calcService.subtract(input1, input2);
}
public double multiply(double input1, double input2){
return calcService.multiply(input1, input2);
}
public double divide(double input1, double input2){
return calcService.divide(input1, input2);
}
}ステップ3：MathApplicationクラスをテストする
calculatorServiceのモックを注入して、MathApplicationクラスをテストしましょう。 モックはEasyMockによって作成されます。
ファイル：MathApplicationTester.java
import org.easymock.EasyMock;
import org.easymock.EasyMockRunner;
import org.easymock.Mock;
import org.easymock.TestSubject;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
//@RunWith attaches a runner with the test class to initialize the test data
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
//@TestSubject annotation is used to identify class which is going to use the mock object
@TestSubject
MathApplication mathApplication = new MathApplication();
//@Mock annotation is used to create the mock object to be injected
@Mock
CalculatorService calcService;
@Test
public void testAdd(){
//add the behavior of calc service to add two numbers
EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);
calcService.serviceUsed();
EasyMock.expectLastCall().times(1,3);
//activate the mock
EasyMock.replay(calcService);
//test the add functionality
Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);
//verify call to calcService is made or not
EasyMock.verify(calcService);
}
}ステップ4：テストケースを実行する
*C：\> EasyMock_WORKSPACE* にTestRunnerという名前のJavaクラスファイルを作成して、テストケースを実行します。ファイル：TestRunner.java
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(MathApplicationTester.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}ステップ5：結果を確認する
次のように javac コンパイラを使用してクラスをコンパイルします。
C:\EasyMock_WORKSPACE>javac Calculator Service.java Math Application.java Math Application Tester.java Test Runner.java次に、テストランナーを実行して結果を確認します。
C:\EasyMock_WORKSPACE>java TestRunner出力を確認します。
trueatLeastOnceを使用した例
ステップ1：数学関数を提供するCalculatorServiceというインターフェイスを作成します
File：CalculatorService.java
public interface CalculatorService {
public double add(double input1, double input2);
public double subtract(double input1, double input2);
public double multiply(double input1, double input2);
public double divide(double input1, double input2);
public void serviceUsed();
}ステップ2：MathApplicationを表すJAVAクラスを作成します
File：MathApplication.java
public class MathApplication {
private CalculatorService calcService;
public void setCalculatorService(CalculatorService calcService){
this.calcService = calcService;
}
public double add(double input1, double input2){
calcService.serviceUsed();
calcService.serviceUsed();
return calcService.add(input1, input2);
}
public double subtract(double input1, double input2){
return calcService.subtract(input1, input2);
}
public double multiply(double input1, double input2){
return calcService.multiply(input1, input2);
}
public double divide(double input1, double input2){
return calcService.divide(input1, input2);
}
}ステップ3：MathApplicationクラスをテストする
calculatorServiceのモックを注入して、MathApplicationクラスをテストしましょう。 モックはEasyMockによって作成されます。
ファイル：MathApplicationTester.java
import org.easymock.EasyMock;
import org.easymock.EasyMockRunner;
import org.easymock.Mock;
import org.easymock.TestSubject;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
//@RunWith attaches a runner with the test class to initialize the test data
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
//@TestSubject annotation is used to identify class which is going to use the mock object
@TestSubject
MathApplication mathApplication = new MathApplication();
//@Mock annotation is used to create the mock object to be injected
@Mock
CalculatorService calcService;
@Test
public void testAdd(){
//add the behavior of calc service to add two numbers
EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);
calcService.serviceUsed();
EasyMock.expectLastCall().atLeastOnce();
//activate the mock
EasyMock.replay(calcService);
//test the add functionality
Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);
//verify call to calcService is made or not
EasyMock.verify(calcService);
}
}ステップ4：テストケースを実行する
*C：\> EasyMock_WORKSPACE* にTestRunnerという名前のJavaクラスファイルを作成して、テストケースを実行します。ファイル：TestRunner.java
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(MathApplicationTester.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}ステップ5：結果を確認する
次のように javac コンパイラを使用してクラスをコンパイルします。
C:\EasyMock_WORKSPACE>javac Calculator Service.java Math Application.java Math Application Tester.java Test Runner.java次に、テストランナーを実行して結果を確認します。
C:\EasyMock_WORKSPACE>java TestRunner出力を確認します。
trueanyTimesを使用した例
ステップ1：数学関数を提供するCalculatorServiceというインターフェイスを作成します
File：CalculatorService.java
public interface CalculatorService {
public double add(double input1, double input2);
public double subtract(double input1, double input2);
public double multiply(double input1, double input2);
public double divide(double input1, double input2);
public void serviceUsed();
}ステップ2：MathApplicationを表すJAVAクラスを作成します
File：MathApplication.java
public class MathApplication {
private CalculatorService calcService;
public void setCalculatorService(CalculatorService calcService){
this.calcService = calcService;
}
public double add(double input1, double input2){
calcService.serviceUsed();
calcService.serviceUsed();
return calcService.add(input1, input2);
}
public double subtract(double input1, double input2){
return calcService.subtract(input1, input2);
}
public double multiply(double input1, double input2){
return calcService.multiply(input1, input2);
}
public double divide(double input1, double input2){
return calcService.divide(input1, input2);
}
}ステップ3：MathApplicationクラスをテストする
calculatorServiceのモックを注入して、MathApplicationクラスをテストしましょう。 モックはEasyMockによって作成されます。
ファイル：MathApplicationTester.java
import org.easymock.EasyMock;
import org.easymock.EasyMockRunner;
import org.easymock.Mock;
import org.easymock.TestSubject;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
//@RunWith attaches a runner with the test class to initialize the test data
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
//@TestSubject annotation is used to identify class which is going to
use the mock object
@TestSubject
MathApplication mathApplication = new MathApplication();
//@Mock annotation is used to create the mock object to be injected
@Mock
CalculatorService calcService;
@Test
public void testAdd(){
//add the behavior of calc service to add two numbers
EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);
calcService.serviceUsed();
EasyMock.expectLastCall().anyTimes();
//activate the mock
EasyMock.replay(calcService);
//test the add functionality
Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);
//verify call to calcService is made or not
EasyMock.verify(calcService);
}
}ステップ4：テストケースを実行する
*C：\> EasyMock_WORKSPACE* にTestRunnerという名前のJavaクラスファイルを作成して、テストケースを実行します。ファイル：TestRunner.java
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(MathApplicationTester.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}ステップ5：結果を確認する
次のように javac コンパイラを使用してクラスをコンパイルします。
C:\EasyMock_WORKSPACE>javac Calculator Service.java Math Application.java Math Application Tester.java Test Runner.java次に、テストランナーを実行して結果を確認します。
C:\EasyMock_WORKSPACE>java TestRunner出力を確認します。
trueEasyMock-例外処理
EasyMockは、モックに例外をスローする機能を提供するため、例外処理をテストできます。 次のコードスニペットをご覧ください。
//add the behavior to throw exception
EasyMock.expect(calc Service.add(10.0,20.0)).and Throw(new Runtime Exception("Add operation not implemented"));ここでは、モックオブジェクトに例外節を追加しました。 MathApplicationはaddメソッドを使用してcalcServiceを使用し、calcService.add（）メソッドが呼び出されるたびにモックはRuntimeExceptionをスローします。
例
ステップ1：数学関数を提供するCalculatorServiceというインターフェイスを作成します
File：CalculatorService.java
public interface CalculatorService {
public double add(double input1, double input2);
public double subtract(double input1, double input2);
public double multiply(double input1, double input2);
public double divide(double input1, double input2);
}ステップ2：MathApplicationを表すJAVAクラスを作成します
File：MathApplication.java
public class MathApplication {
private CalculatorService calcService;
public void setCalculatorService(CalculatorService calcService){
this.calcService = calcService;
}
public double add(double input1, double input2){
return calcService.add(input1, input2);
}
public double subtract(double input1, double input2){
return calcService.subtract(input1, input2);
}
public double multiply(double input1, double input2){
return calcService.multiply(input1, input2);
}
public double divide(double input1, double input2){
return calcService.divide(input1, input2);
}
}ステップ3：MathApplicationクラスをテストする
calculatorServiceのモックを注入して、MathApplicationクラスをテストしましょう。 モックはEasyMockによって作成されます。
ファイル：MathApplicationTester.java
import org.easymock.EasyMock;
import org.easymock.EasyMockRunner;
import org.easymock.Mock;
import org.easymock.TestSubject;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
//@RunWith attaches a runner with the test class to initialize the test data
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
//@TestSubject annotation is used to identify class which is going to use the mock object
@TestSubject
MathApplication mathApplication = new MathApplication();
//@Mock annotation is used to create the mock object to be injected
@Mock
CalculatorService calcService;
@Test(expected = RuntimeException.class)
public void testAdd(){
//add the behavior to throw exception
EasyMock.expect(calcService.add(10.0,20.0)).andThrow(new
RuntimeException("Add operation not implemented"));
//activate the mock
EasyMock.replay(calcService);
//test the add functionality
Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);
//verify call to calcService is made or not
EasyMock.verify(calcService);
}
}ステップ4：テストケースを実行する
*C：\> EasyMock_WORKSPACE* にTestRunnerという名前のJavaクラスファイルを作成して、テストケースを実行します。ファイル：TestRunner.java
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(MathApplicationTester.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}ステップ5：結果を確認する
次のように javac コンパイラを使用してクラスをコンパイルします。
C:\EasyMock_WORKSPACE>javac MathApplicationTester.java次に、テストランナーを実行して結果を確認します。
C:\EasyMock_WORKSPACE>java TestRunner出力を確認します。
trueEasyMock-createMock
これまで、アノテーションを使用してモックを作成してきました。 EasyMockは、モックオブジェクトを作成するためのさまざまなメソッドを提供します。 EasyMock.createMock（）は、モックがアクションの途中で行うメソッド呼び出しの順序を気にせずにモックを作成します。
構文
calcService = EasyMock.createMock(CalculatorService.class);例
ステップ1：数学関数を提供するCalculatorServiceというインターフェイスを作成します
File：CalculatorService.java
public interface CalculatorService {
public double add(double input1, double input2);
public double subtract(double input1, double input2);
public double multiply(double input1, double input2);
public double divide(double input1, double input2);
}ステップ2：MathApplicationを表すJAVAクラスを作成します
File：MathApplication.java
public class MathApplication {
private CalculatorService calcService;
public void setCalculatorService(CalculatorService calcService){
this.calcService = calcService;
}
public double add(double input1, double input2){
return calcService.add(input1, input2);
}
public double subtract(double input1, double input2){
return calcService.subtract(input1, input2);
}
public double multiply(double input1, double input2){
return calcService.multiply(input1, input2);
}
public double divide(double input1, double input2){
return calcService.divide(input1, input2);
}
}ステップ3：MathApplicationクラスをテストする
calculatorServiceのモックを注入して、MathApplicationクラスをテストしましょう。 モックはEasyMockによって作成されます。
ここでは、exp（）を介して2つのモックメソッド呼び出しadd（）とminus（）をモックオブジェクトに追加しました。 ただし、テスト中は、add（）を呼び出す前に、subtract（）を呼び出しました。 EasyMock.createMock（）を使用してモックオブジェクトを作成する場合、メソッドの実行順序は重要ではありません。
ファイル：MathApplicationTester.java
import org.easymock.EasyMock;
import org.easymock.EasyMockRunner;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
private MathApplication mathApplication;
private CalculatorService calcService;
@Before
public void setUp(){
mathApplication = new MathApplication();
calcService = EasyMock.createMock(CalculatorService.class);
mathApplication.setCalculatorService(calcService);
}
@Test
public void testAddAndSubtract(){
//add the behavior to add numbers
EasyMock.expect(calcService.add(20.0,10.0)).andReturn(30.0);
//subtract the behavior to subtract numbers
EasyMock.expect(calcService.subtract(20.0,10.0)).andReturn(10.0);
//activate the mock
EasyMock.replay(calcService);
//test the subtract functionality
Assert.assertEquals(mathApplication.subtract(20.0, 10.0),10.0,0);
//test the add functionality
Assert.assertEquals(mathApplication.add(20.0, 10.0),30.0,0);
//verify call to calcService is made or not
EasyMock.verify(calcService);
}
}ステップ4：テストケースを実行する
*C：\> EasyMock_WORKSPACE* にTestRunnerという名前のJavaクラスファイルを作成して、テストケースを実行します。ファイル：TestRunner.java
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(MathApplicationTester.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}ステップ5：結果を確認する
次のように javac コンパイラを使用してクラスをコンパイルします。
C:\EasyMock_WORKSPACE>javac MathApplicationTester.java次に、テストランナーを実行して結果を確認します。
C:\EasyMock_WORKSPACE>java TestRunner出力を確認します。
trueEasyMock-createStrictMock
EasyMock.createStrictMock（）はモックを作成し、そのアクションの間にモックが行うメソッド呼び出しの順序も処理します。
構文
calcService = EasyMock.createStrictMock(CalculatorService.class);例
ステップ1：数学関数を提供するCalculatorServiceというインターフェイスを作成します
File：CalculatorService.java
public interface CalculatorService {
public double add(double input1, double input2);
public double subtract(double input1, double input2);
public double multiply(double input1, double input2);
public double divide(double input1, double input2);
}ステップ2：MathApplicationを表すJAVAクラスを作成します
File：MathApplication.java
public class MathApplication {
private CalculatorService calcService;
public void setCalculatorService(CalculatorService calcService){
this.calcService = calcService;
}
public double add(double input1, double input2){
return calcService.add(input1, input2);
}
public double subtract(double input1, double input2){
return calcService.subtract(input1, input2);
}
public double multiply(double input1, double input2){
return calcService.multiply(input1, input2);
}
public double divide(double input1, double input2){
return calcService.divide(input1, input2);
}
}ステップ3：MathApplicationクラスをテストする
calculatorServiceのモックを注入して、MathApplicationクラスをテストしましょう。 モックはEasyMockによって作成されます。
ここでは、exp（）を介して2つのモックメソッド呼び出しadd（）とminus（）をモックオブジェクトに追加しました。 ただし、テスト中は、add（）を呼び出す前に、subtract（）を呼び出しました。 EasyMock.createStrictMock（）を使用してモックオブジェクトを作成する場合、メソッドの実行順序は重要です。
ファイル：MathApplicationTester.java
import org.easymock.EasyMock;
import org.easymock.EasyMockRunner;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
private MathApplication mathApplication;
private CalculatorService calcService;
@Before
public void setUp(){
mathApplication = new MathApplication();
calcService = EasyMock.createStrictMock(CalculatorService.class);
mathApplication.setCalculatorService(calcService);
}
@Test
public void testAddAndSubtract(){
//add the behavior to add numbers
EasyMock.expect(calcService.add(20.0,10.0)).andReturn(30.0);
//subtract the behavior to subtract numbers
EasyMock.expect(calcService.subtract(20.0,10.0)).andReturn(10.0);
//activate the mock
EasyMock.replay(calcService);
//test the subtract functionality
Assert.assertEquals(mathApplication.subtract(20.0, 10.0),10.0,0);
//test the add functionality
Assert.assertEquals(mathApplication.add(20.0, 10.0),30.0,0);
//verify call to calcService is made or not
EasyMock.verify(calcService);
}
}ステップ4：テストケースを実行する
*C：\> EasyMock_WORKSPACE* にTestRunnerという名前のJavaクラスファイルを作成して、テストケースを実行します。ファイル：TestRunner.java
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(MathApplicationTester.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}ステップ5：結果を確認する
次のように javac コンパイラを使用してクラスをコンパイルします。
C:\EasyMock_WORKSPACE>javac MathApplicationTester.java次に、テストランナーを実行して結果を確認します。
C:\EasyMock_WORKSPACE>java TestRunner出力を確認します。
testAddAndSubtract(com.finddevguides.mock.MathApplicationTester):
Unexpected method call CalculatorService.subtract(20.0, 10.0):
CalculatorService.add(20.0, 10.0): expected: 1, actual: 0
falseEasyMock-createNiceMock
EasyMock.createNiceMock（）は、モックを作成し、モックの各メソッドのデフォルト実装を設定します。 EasyMock.createMock（）が使用されている場合、mockメソッドを呼び出すとアサーションエラーがスローされます。
構文
calcService = EasyMock.createNiceMock(CalculatorService.class);例
ステップ1：数学関数を提供するCalculatorServiceというインターフェイスを作成します。
File：CalculatorService.java
public interface CalculatorService {
public double add(double input1, double input2);
public double subtract(double input1, double input2);
public double multiply(double input1, double input2);
public double divide(double input1, double input2);
}ステップ2：MathApplicationを表すJAVAクラスを作成します
File：MathApplication.java
public class MathApplication {
private CalculatorService calcService;
public void setCalculatorService(CalculatorService calcService){
this.calcService = calcService;
}
public double add(double input1, double input2){
return calcService.add(input1, input2);
}
public double subtract(double input1, double input2){
return calcService.subtract(input1, input2);
}
public double multiply(double input1, double input2){
return calcService.multiply(input1, input2);
}
public double divide(double input1, double input2){
return calcService.divide(input1, input2);
}
}ステップ3：MathApplicationクラスをテストする
calculatorServiceのモックを注入して、MathApplicationクラスをテストしましょう。 モックはEasyMockによって作成されます。
ここでは、expect（）を介して1つのモックメソッド呼び出しadd（）を追加しました。 ただし、テスト中に、subtract（）などのメソッドも呼び出しました。 EasyMock.createNiceMock（）を使用してモックオブジェクトを作成すると、デフォルト値を持つデフォルトの実装が利用可能になります。
ファイル：MathApplicationTester.java
import org.easymock.EasyMock;
import org.easymock.EasyMockRunner;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
private MathApplication mathApplication;
private CalculatorService calcService;
@Before
public void setUp(){
mathApplication = new MathApplication();
calcService = EasyMock.createNiceMock(CalculatorService.class);
mathApplication.setCalculatorService(calcService);
}
@Test
public void testCalcService(){
//add the behavior to add numbers
EasyMock.expect(calcService.add(20.0,10.0)).andReturn(30.0);
//activate the mock
EasyMock.replay(calcService);
//test the add functionality
Assert.assertEquals(mathApplication.add(20.0, 10.0),30.0,0);
//test the subtract functionality
Assert.assertEquals(mathApplication.subtract(20.0, 10.0),0.0,0);
//test the multiply functionality
Assert.assertEquals(mathApplication.divide(20.0, 10.0),0.0,0);
//test the divide functionality
Assert.assertEquals(mathApplication.multiply(20.0, 10.0),0.0,0);
//verify call to calcService is made or not
EasyMock.verify(calcService);
}
}ステップ4：テストケースを実行する
テストケースを実行するには、* C：\> EasyMock_WORKSPACE *にTestRunnerという名前のJavaクラスファイルを作成します。
ファイル：TestRunner.java
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(MathApplicationTester.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}ステップ5：結果を確認する
次のように javac コンパイラを使用してクラスをコンパイルします。
C:\EasyMock_WORKSPACE>javac MathApplicationTester.java次に、テストランナーを実行して結果を確認します。
C:\EasyMock_WORKSPACE>java TestRunner出力を確認します。
trueEasyMock-EasyMockSupport
EasyMockSupportは、テストクラスのユーティリティクラスまたはヘルパークラスです。 次の機能を提供します。
- * replayAll（）* –作成されたすべてのモックを1つのバッチに登録します。
- * verifyAll（）* – 1つのバッチですべての模擬操作を検証します。
- * resetAll（）* – 1つのバッチ内のすべてのモック操作をリセットします。
例
ステップ1：数学関数を提供するCalculatorServiceというインターフェイスを作成します
File：CalculatorService.java
public interface CalculatorService {
public double add(double input1, double input2);
public double subtract(double input1, double input2);
public double multiply(double input1, double input2);
public double divide(double input1, double input2);
}ステップ2：MathApplicationを表すJAVAクラスを作成します
File：MathApplication.java
public class MathApplication {
private CalculatorService calcService;
public void setCalculatorService(CalculatorService calcService){
this.calcService = calcService;
}
public double add(double input1, double input2){
return calcService.add(input1, input2);
}
public double subtract(double input1, double input2){
return calcService.subtract(input1, input2);
}
public double multiply(double input1, double input2){
return calcService.multiply(input1, input2);
}
public double divide(double input1, double input2){
return calcService.divide(input1, input2);
}
}ステップ3：MathApplicationクラスをテストする
calculatorServiceのモックを注入して、MathApplicationクラスをテストしましょう。 モックはEasyMockによって作成されます。
ファイル：MathApplicationTester.java
import org.easymock.EasyMockRunner;
import org.easymock.EasyMockSupport;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@RunWith(EasyMockRunner.class)
public class MathApplicationTester extends EasyMockSupport {
private MathApplication mathApplication1;
private MathApplication mathApplication2;
private CalculatorService calcService1;
private CalculatorService calcService2;
@Before
public void setUp(){
mathApplication1 = new MathApplication();
mathApplication2 = new MathApplication();
calcService1 = createNiceMock(CalculatorService.class);
calcService2 = createNiceMock(CalculatorService.class);
mathApplication1.setCalculatorService(calcService1);
mathApplication2.setCalculatorService(calcService2);
}
@Test
public void testCalcService(){
//activate all mocks
replayAll();
//test the add functionality
Assert.assertEquals(mathApplication1.add(20.0, 10.0),0.0,0);
//test the subtract functionality
Assert.assertEquals(mathApplication1.subtract(20.0, 10.0),0.0,0);
//test the multiply functionality
Assert.assertEquals(mathApplication1.divide(20.0, 10.0),0.0,0);
//test the divide functionality
Assert.assertEquals(mathApplication1.multiply(20.0, 10.0),0.0,0);
//test the add functionality
Assert.assertEquals(mathApplication2.add(20.0, 10.0),0.0,0);
//test the subtract functionality
Assert.assertEquals(mathApplication2.subtract(20.0, 10.0),0.0,0);
//test the multiply functionality
Assert.assertEquals(mathApplication2.divide(20.0, 10.0),0.0,0);
//test the divide functionality
Assert.assertEquals(mathApplication2.multiply(20.0, 10.0),0.0,0);
//verify all the mocks
verifyAll();
}
}ステップ4：テストケースを実行する
*C：\> EasyMock_WORKSPACE* にTestRunnerという名前のJavaクラスファイルを作成して、テストケースを実行します。ファイル：TestRunner.java
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(MathApplicationTester.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}ステップ5：結果を確認する
次のようにjavacコンパイラを使用してクラスをコンパイルします。
C:\EasyMock_WORKSPACE>javac MathApplicationTester.java次に、テストランナーを実行して結果を確認します。
C:\EasyMock_WORKSPACE>java TestRunner出力を確認します。
true