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

出力を確認する 

pass

EasyMock-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

出力を確認します。 

true

JUnitの詳細については、チュートリアルポイントの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>
false

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 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

出力を確認します。 

true

EasyMock-動作の​​検証

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

出力を確認します。 

true

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

出力を確認します。 

testAdd(MathApplicationTester):
   Expectation failure on verify:
      CalculatorService.add(10.0, 20.0): expected: 1, actual: 0
false

EasyMock-コールを期待する

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

出力を確認します。 

true

2回呼び出される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
false

calcService.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
false

EasyMock-さまざまな通話

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

出力を確認します。 

true

atLeastOnceを使用した例

ステップ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

出力を確認します。 

true

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();
      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

出力を確認します。 

true

EasyMock-例外処理

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

出力を確認します。 

true

EasyMock-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

出力を確認します。 

true

EasyMock-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
false

EasyMock-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

出力を確認します。 

true

EasyMock-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
「https://www.finddevguides.com/index.php?title=Easymock-quick-guide&oldid=78870」から取得
Powered by MediaWiki