devkuma – Java

JUnit

kc@example.com (kc kim) — Mon, 01 Jan 0001 00:00:00 +0000

JUnit 5の適用方法

kc@example.com (kc kim) — Wed, 21 Sep 2022 18:10:00 +0900

ビルド環境

Gradle環境では、次のようなビルドファイル(build.gradle)が必要である。

build.gradle

plugins {
    id 'java'
}

group 'com.devkuma'
version '1.0-SNAPSHOT'

repositories {
    mavenCentral()
}

dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1'
}

test {
    useJUnitPlatform()
}

依存関係としてorg.junit.jupiter:junit-jupiter-apiが必要である。

IDEでプロジェクトを作成すると、次のようなディレクトリ構造になる。

.
├── build.gradle
├── gradle
│   └── wrapper
│       ├── gradle-wrapper.jar
│       └── gradle-wrapper.properties
├── gradlew
├── gradlew.bat
├── settings.gradle
└── src
    ├── main
    │   ├── java
    │   │   └── com
    │   │       └── devkuma
    │   │           └── Main.java
    │   └── resources
    └── test
        ├── java
        └── resources

テストコードの作成

/src/test/java/com/devkuma/junit5/JUnit5Test.java

package com.devkuma.junit5;

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

class JUnit5Test {
    @Test
    void success() {
        Assertions.assertEquals(3, 3);
    }

    @Test
    void fail() {
        Assertions.assertEquals(3, 5);
    }

    static class StaticTest {
        @Test
        void success() {
            Assertions.assertEquals(3, 3);
        }

        @Test
        void fail() {
            Assertions.assertEquals(3, 5);
        }
    }

    class InnerTest {
        @Test
        void success() {
            Assertions.assertEquals(3, 3);
        }

        @Test
        void fail() {
            Assertions.assertEquals(3, 5);
        }
    }
}

Spring Bootでの適用方法

Spring Boot 2.2以降ではJUnit 5が標準で提供されている。JUnit 5を使う場合、追加設定なしでstarter-testに含まれる。

Spring Boot 2.2.x以降

testImplementation("org.springframework.boot:spring-boot-starter-test")
 
test {
    useJUnitPlatform()
}

Spring Boot 2.2.x以前

testImplementation("org.springframework.boot:spring-boot-starter-test") {
     exclude module : 'junit' 
}

testImplementation("org.junit.jupiter:junit-jupiter-api")
testCompile("org.junit.jupiter:junit-jupiter-params")
testRuntime("org.junit.jupiter:junit-jupiter-engine")

test {
     useJUnitPlatform() 
}

JUnit 5概要

kc@example.com (kc kim) — Wed, 21 Sep 2022 18:10:00 +0900

JUnitとは？

JUnitとは、Javaの単体テストのためのフレームワークである。オブジェクトのインスタンスを作成してロジックを実行し、結果値が期待値と一致するかを比較したり、ファイル、ネットワーク接続、データベース連携などのテストを実行したりできる。

JUnitはassert関連メソッドを提供し、テスト時に真偽、null、同一オブジェクトかどうかなどを検査できる。基本的には@Testアノテーションでテスト対象メソッドを指定し、BeforeやAfterでテスト前後に実行する処理を指定する。

JUnitはJava向けのオープンソーステストフレームワークであり、『Design Patterns』を著したGoFの一員であるErich Gammaと、XPで有名なKent Beckが共同で開発した。JUnitは意図をコードで簡潔に表現し、そのコードが期待どおりに動作するかを検証する方法を提供する。もともとJUnitはIDEや開発ツール環境とは別に使えるテストフレームワークで、コンソール環境のコマンドラインやGUI環境で利用できる。

単体テストと機能テスト

単体テスト

単体テスト(unit test)は、プログラムの基本単位が内部設計仕様どおりに正しく動作するかをテストすることである。Javaでは基本単位がクラスなので、各クラスに含まれるメソッドが正しく動作するかをテストすればよい。そのため、単体テストの範囲は非常に限定される。

機能テスト

機能テスト(functional test)は、ソフトウェア全体が正しく動作するかを確認するテストである。ソフトウェアシステム全体を1つのブラックボックスとして見て、ユーザーの立場から各機能が正しく動作するかをテストする。機能テストは通常、別のテストチームが実施し、開発時とは異なるツールや技術を使用する。

JUnit 5サポート

JUnit 4
- Java 1.4以上
JUnit 5
- JUnit 5はJava 1.8以上

JUnit 5の構成

JUnit 4の構成はAll in Oneだったが、JUnit 5の構成はPlatform、Jupiter、Vintageに細分化された。

テストフレームワークを実行するための基礎モジュール
- JUnit Platform: JVM上でテストフレームワークを実行するための基礎的な役割を担う。また、テスト開発のためのAPIを提供する。
具体的なテストフレームワークモジュール
- JUnit Jupiter: JUnit 5のテストおよびExtensionを作るための新しいプログラミングモデルと拡張モデルを組み合わせたTestEngineを提供する。
- JUnit Vintage: 下位互換性のためにJUnit 4、JUnit 3を実行できるTestEngineである。

Design Pattern | Abstract Factory Methods

kc@example.com (kc kim) — Thu, 17 Mar 2022 15:26:00 +0900

Abstract Factoryパターンとは?

Abstract Factoryは抽象工場という意味である。
抽象的であるとは、具体的にどのように実装されているかは考慮せず、インターフェースだけに注目している状態である。
Abstract Factoryパターンは、部品の具体的な実装に注目せず、インターフェースに注目する。そして、そのインターフェースだけを使って部品を組み立て、製品としてまとめる方式である。
関連部品を組み合わせて製品を作るものである。
GoFデザインパターンでは、生成に関するデザインパターンに分類される。

Abstract Factoryパターンのサンプルプログラム

お気に入り一覧をHTML形式で出力するサンプルプログラムである。

Class Diagram

1. Factoryクラス

抽象工場を代表するクラスである。Link、Tray、Pageを作る。

Factory.java

package com.devkuma.designpattern.creational.abstractfactory.factory;

public abstract class Factory {

    public abstract Link createLink(String caption, String url);

    public abstract Tray createTray(String caption);

    public abstract Page createPage(String title);

    public static Factory getFactory(String classname) {
        Factory factory = null;
        try {
            factory = (Factory) Class.forName(classname).getDeclaredConstructor().newInstance();
        } catch (ClassNotFoundException e) {
            System.err.println("클래스 " + classname + "를 찾을 수 없습니다.");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return factory;
    }
}

2. Itemクラス

LinkとTrayを統一的に扱うクラスである。

Item.java

package com.devkuma.designpattern.creational.abstractfactory.factory;

public abstract class Item {
    protected String caption;

    public Item(String caption) {
        this.caption = caption;
    }

    public abstract String makeHTML();
}

3. Linkクラス

抽象部品: HTMLリンクを表すクラスである。

Link.java

package com.devkuma.designpattern.creational.abstractfactory.factory;

public abstract class Link extends Item {
    protected String url;

    public Link(String caption, String url) {
        super(caption);
        this.url = url;
    }
}

4. Trayクラス

抽象部品: LinkとTrayを集めたクラスである。

Tray.java

package com.devkuma.designpattern.creational.abstractfactory.factory;

import java.util.ArrayList;

public abstract class Tray extends Item {
    protected ArrayList tray = new ArrayList();

    public Tray(String caption) {
        super(caption);
    }

    public void add(Item item) {
        tray.add(item);
    }
}

5. Pageクラス

抽象部品: HTMLページを表すクラスである。

Page.java

package com.devkuma.designpattern.creational.abstractfactory.factory;

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.ArrayList;

public abstract class Page {
    protected String title;
    protected ArrayList content = new ArrayList();

    public Page(String title) {
        this.title = title;
    }

    public void add(Item item) {
        content.add(item);
    }

    public void output() {
        try {
            String filename = title + ".html";
            Writer writer = new FileWriter(filename);
            writer.write(this.makeHTML());
            writer.close();
            System.out.println(filename + "을 생성했습니다.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public abstract String makeHTML();
}

6. ListFactoryクラス

具体的な工場を表すクラスである。ListLink、ListTray、ListPageを作る。

ListFactory.java

package com.devkuma.designpattern.creational.abstractfactory.listfactory;

import com.devkuma.designpattern.creational.abstractfactory.factory.Factory;
import com.devkuma.designpattern.creational.abstractfactory.factory.Link;
import com.devkuma.designpattern.creational.abstractfactory.factory.Page;
import com.devkuma.designpattern.creational.abstractfactory.factory.Tray;

public class ListFactory extends Factory {
    public Link createLink(String caption, String url) {
        return new ListLink(caption, url);
    }

    public Tray createTray(String caption) {
        return new ListTray(caption);
    }

    public Page createPage(String title) {
        return new ListPage(title);
    }
}

7. ListLinkクラス

具体的な部品: HTMLリンクを表すクラスである。

ListLink.java

package com.devkuma.designpattern.creational.abstractfactory.listfactory;

import com.devkuma.designpattern.creational.abstractfactory.factory.Link;

public class ListLink extends Link {
    public ListLink(String caption, String url) {
        super(caption, url);
    }

    public String makeHTML() {
        return "  <li><a href=\"" + url + "\">" + caption + "</a></li>\n";
    }
}

8. ListTrayクラス

具体的な部品: LinkやTrayを集めたクラスである。

ListTray.java

package com.devkuma.designpattern.creational.abstractfactory.listfactory;

import com.devkuma.designpattern.creational.abstractfactory.factory.Item;
import com.devkuma.designpattern.creational.abstractfactory.factory.Tray;

import java.util.Iterator;

public class ListTray extends Tray {
    public ListTray(String caption) {
        super(caption);
    }

    public String makeHTML() {
        StringBuffer buffer = new StringBuffer();
        buffer.append("<li>\n");
        buffer.append(caption + "\n");
        buffer.append("<ul>\n");
        Iterator it = tray.iterator();
        while (it.hasNext()) {
            Item item = (Item) it.next();
            buffer.append(item.makeHTML());
        }
        buffer.append("</ul>\n");
        buffer.append("</li>\n");
        return buffer.toString();
    }
}

9. ListPageクラス

具体的な部品: HTMLページを表すクラスである。

ListPage.java

package com.devkuma.designpattern.creational.abstractfactory.listfactory;

import com.devkuma.designpattern.creational.abstractfactory.factory.Item;
import com.devkuma.designpattern.creational.abstractfactory.factory.Page;

import java.util.Iterator;

public class ListPage extends Page {
    public ListPage(String title) {
        super(title);
    }

    public String makeHTML() {
        StringBuffer buffer = new StringBuffer();
        buffer.append("<html><head><title>" + title + "</title></head>\n");
        buffer.append("<body>\n");
        buffer.append("<h1>" + title + "</h1>\n");
        buffer.append("<ul>\n");
        Iterator it = content.iterator();
        while (it.hasNext()) {
            Item item = (Item) it.next();
            buffer.append(item.makeHTML());
        }
        buffer.append("</ul>\n");
        buffer.append("</body></html>\n");
        return buffer.toString();
    }
}

10. Mainクラス

メイン処理を実行するクラスである。

Main.java

package com.devkuma.designpattern.creational.abstractfactory;

import com.devkuma.designpattern.creational.abstractfactory.factory.Factory;
import com.devkuma.designpattern.creational.abstractfactory.factory.Link;
import com.devkuma.designpattern.creational.abstractfactory.factory.Page;
import com.devkuma.designpattern.creational.abstractfactory.factory.Tray;

public class Main {
    public static void main(String[] args) {

        Factory factory = Factory.getFactory("com.devkuma.designpattern.creational.abstractfactory.listfactory.ListFactory");

        Link devkuma = factory.createLink("Devkuma", "https://www.devkuma.com//");
        Link araikuma = factory.createLink("araikuma", "https://araikuma.tistory.com/");

        Link naver = factory.createLink("Naver", "https://www.naver.com/");
        Link daum = factory.createLink("Daum", "https://www.daum.com/");
        Link google = factory.createLink("Google", "https://www.google.com/");

        Tray pgTray = factory.createTray("프로그래밍");
        pgTray.add(devkuma);
        pgTray.add(araikuma);

        Tray searchTray = factory.createTray("검색사이트");
        searchTray.add(naver);
        searchTray.add(daum);
        searchTray.add(google);

        Page page = factory.createPage("즐겨찾기");
        page.add(pgTray);
        page.add(searchTray);
        page.output();
    }
}

11. 実行結果

プログラムで生成したファイルは以下のとおりである。

즐겨찾기.html

<html><head><title>즐겨찾기</title></head>
<body>
<h1>즐겨찾기</h1>
<ul>
<li>
프로그래밍
<ul>
  <li><a href="https://www.devkuma.com//">Devkuma</a></li>
  <li><a href="https://araikuma.tistory.com/">araikuma</a></li>
</ul>
</li>
<li>
검색사이트
<ul>
  <li><a href="https://www.naver.com/">Naver</a></li>
  <li><a href="https://www.daum.com/">Daum</a></li>
  <li><a href="https://www.google.com/">Google</a></li>
</ul>
</li>
</ul>
</body></html>

Abstract Factoryパターンのメリット

例えば、サンプルプログラムに新しい具体的な工場を追加する場合、Factory、Link、Tray、Pageのサブクラスを作り、それぞれの抽象メソッドを実装することになる。
つまり、factoryパッケージのクラスが持っている抽象部分を具体化していくだけである。このとき、どれだけ具体的な工場を追加しても、抽象工場を修正する必要はない。

JUnit 5テスト実行方法 - ConsoleLauncher, Gradle

kc@example.com (kc kim) — Sun, 11 Dec 2022 10:26:00 +0900

ConsoleLauncherの使い方

JUnit 5を実行するためのコマンドラインツールとして、ConsoleLauncherが用意されている。JARファイルとして配布されているため、Maven Central Repositoryからダウンロードして使用する。この例ではバージョン1.9.1を使用した。

テスト実行方法

テストクラスは通常、build/classes/java/testまたはtarget/test-classesに配置される。

テストクラスパス上のすべてのテストを実行する:

$ java -jar junit-platform-console-standalone-1.9.1.jar \
    --classpath build/classes/java/test \
    --scan-classpath

--classpathは-cpに短縮できる。JUnit 5のクラスはstandalone JARに含まれており、-cpにはテストで使用する追加依存関係を指定できる。

特定クラスを実行する:

$ java -jar junit-platform-console-standalone-1.9.1.jar \
    -cp build/classes/java/test \
    --select-class com.devkuma.junit5.JUnit5Test

--select-classは-cに短縮できる。--select-packageでパッケージを選択したり、--include-classnameと正規表現でクラス名を絞り込むこともできる。

テスト実行出力

テスト結果はコンソールに出力される。成功、失敗、失敗詳細、コンテナ数、テスト数などが含まれる。

コマンドヘルプ

ConsoleLauncherには他にも多くのオプションがある。次のコマンドで確認できる。

$ java -jar junit-platform-console-standalone-1.9.1.jar --help

Gradleでのテスト実行

多くの場合、テストは使用しているビルドツールから実行する。Gradleは4.6からJUnit 5の実行を標準でサポートしている。

Gradle設定

GradleはJUnit 4やTestNGなど他のテストフレームワークもサポートする。JUnit 5を使う場合は、useJUnitPlatform()を明示的に宣言する。

build.gradle

test {
    useJUnitPlatform()
}

テストコード実行

すべてのテストが成功した場合、GradleはBUILD SUCCESSFULを出力する。失敗が含まれる場合、testタスクは失敗し、失敗したテスト名とbuild/reports/tests/test/index.htmlなどのレポートパスが表示される。

静的ネストクラスはテストとして実行できるが、通常の内部クラスはデフォルトでは実行されない。

Design Pattern | Builder Pattern(ビルダーパターン)

kc@example.com (kc kim) — Mon, 14 Mar 2022 00:25:00 +0900

Builderパターンとは?

Buildという単語は、構造を持つ大きなものを構築するという意味である。
複雑な構造を持つものを作るとき、一度に完成させるのは難しい。まず全体を構成する各部分を作り、段階を踏んで組み立てていくことになる。
同じ構築工程で、異なる表現オブジェクトを生成する。
コンストラクタに入るパラメータが多くても少なくても、順番にパラメータを受け取り、すべてのパラメータを受け取った後にこれらの変数を統合して一度に使用する。
Builderパターンは、構造を持つインスタンスを構築する方法である。
GoFデザインパターンでは、生成に関するデザインパターンに分類される。

Builderパターンのサンプルプログラム

文書を通常のテキストおよびHTML形式で出力するサンプルプログラムである。

Class Diagram

1. Builderクラス

文書を構成するためのメソッドを定義した抽象クラスである。

Builder.java

public abstract class Builder {
    public abstract void makeTitle(String title);
    public abstract void makeString(String str);
    public abstract void makeItems(String[] items);
    public abstract void close();
}

2. Guideクラス

1つの文書を作るクラスである。

Guide.java

package com.devkuma.designpattern.creational.builder;

public class Guide {

    private Builder builder;

    public Guide(Builder builder) {
        this.builder = builder;
    }

    public void construct() {
        builder.makeTitle("야유회에 대해서");
        builder.makeString("일시");
        builder.makeItems(new String[]{
                "2022/3/14 (월)",
                "11:00~",
        });
        builder.makeString("장소");
        builder.makeItems(new String[]{
                "xxx 캠핌장",
        });
        builder.makeString("준비물");
        builder.makeItems(new String[]{
                "회비",
                "고기",
                "음료수",
        });
        builder.close();
    }
}

3. TextBuilderクラス

通常のテキストで文書を作るクラスである。

TextBuilder.java

package com.devkuma.designpattern.creational.builder;

public class TextBuilder extends Builder {

    private StringBuffer buffer = new StringBuffer();

    public void makeTitle(String title) {
        buffer.append("==============================\n");
        buffer.append("'" + title + "'\n");
        buffer.append("\n");
    }

    public void makeString(String str) {
        buffer.append("- " + str + "\n");
    }

    public void makeItems(String[] items) {
        for (int i = 0; i < items.length; i++) {
            buffer.append("　- " + items[i] + "\n");
        }
        buffer.append("\n");
    }

    public void close() {
        buffer.append("==============================\n");
    }

    public String getResult() {
        return buffer.toString();
    }
}

4. HTMLBuilderクラス

HTMLファイルとして文書を作成するクラスである。

HTMLBuilder.java

package com.devkuma.designpattern.creational.builder;

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class HtmlBuilder extends Builder {

    private String filename;
    private PrintWriter writer;

    public void makeTitle(String title) {
        filename = title + ".html";
        try {
            writer = new PrintWriter(new FileWriter(filename));
        } catch (IOException e) {
            e.printStackTrace();
        }
        writer.println("<html><head><title>" + title + "</title></head><body>");
        writer.println("<h1>" + title + "</h1>");
    }

    public void makeString(String str) {
        writer.println("<p>" + str + "</p>");
    }

    public void makeItems(String[] items) {
        writer.println("<ul>");
        for (int i = 0; i < items.length; i++) {
            writer.println("<li>" + items[i] + "</li>");
        }
        writer.println("</ul>");
    }

    public void close() {
        writer.println("</body></html>");
        writer.close();
    }

    public String getResult() {
        return filename;
    }
}

5. Mainクラス

サンプルプログラムを実行するメインクラスである。

Main.java

package com.devkuma.designpattern.creational.builder;

public class Main {
    public static void main(String[] args) {

        if (args.length != 1) {
            System.exit(0);
        }
        if (args[0].equals("plain")) {
            TextBuilder textbuilder = new TextBuilder();
            Guide guide = new Guide(textbuilder);
            guide.construct();
            String result = textbuilder.getResult();
            System.out.println(result);
        } else if (args[0].equals("html")) {
            HtmlBuilder htmlbuilder = new HtmlBuilder();
            Guide guide = new Guide(htmlbuilder);
            guide.construct();
            String filename = htmlbuilder.getResult();
            System.out.println(filename + "이 작성되었습니다.");
        } else {
            System.exit(0);
        }
    }
}

6. 実行結果

テキスト

==============================
'야유회에 대해서'

- 일시
　- 2022/3/14 (월)
　- 11:00~

- 장소
　- xxx 캠핌장

- 준비물
　- 회비
　- 고기
　- 음료수

==============================

HTML

<html><head><title>야유회에 대해서</title></head><body>
<h1>야유회에 대해서</h1>
<p>일시</p>
<ul>
<li>2022/3/14 (월)</li>
<li>11:00~</li>
</ul>
<p>장소</p>
<ul>
<li>xxx 캠핌장</li>
</ul>
<p>준비물</p>
<ul>
<li>회비</li>
<li>고기</li>
<li>음료수</li>
</ul>
</body></html>

7. Builderパターンのメリット

サンプルプログラムを見ると、Mainクラスは文書の構築方法(Builderクラスのメソッド)を知らない。MainクラスはGuideクラスのconstructメソッドを呼び出すだけで文書を構築できる。
そして、GuideクラスはBuilderクラスを使って文書を作成するが、Guideクラスは自分が実際に利用しているクラスが何か(TextBuilderなのかHtmlBuilderなのか)を知らない。
TextBuilderのインスタンスをGuideに渡しても、HTMLBuilderのインスタンスをGuideに渡しても正しく機能するのは、GuideクラスがBuilderクラスの具体的なクラスを知らないためである。
知らないからこそ差し替えが可能であり、差し替えが可能だからこそ部品としての価値が高くなる。

Design Pattern | Prototype Pattern(プロトタイプパターン)

kc@example.com (kc kim) — Mon, 14 Mar 2022 01:24:00 +0900

Prototypeパターンとは?

Prototypeという英単語は、原型や模範という意味である。
Prototypeパターンは、new Xxx()でクラスからインスタンスを生成するのではなく、インスタンスから別のインスタンスを生成する方式である。つまり、コピーしてインスタンスを作る。
複製を作る作業をcloneと言う。
GoFデザインパターンでは、生成に関するデザインパターンに分類される。

Prototypeパターンのサンプルプログラム

入力した文字列に下線を引いたり、囲んだりするサンプルプログラムである。

Class Diagram

1. Productインターフェース

複製メソッドを定義するインターフェースである。JavaのCloneableインターフェースを継承する。

Product.java

package com.devkuma.designpattern.creational.prototype.framework;

import java.lang.Cloneable;

public interface Product extends Cloneable {
    void use(String s);

    Product createClone();
}

2. Managerクラス

Productの生成指示や管理を行うクラスである。

Manager.java

package com.devkuma.designpattern.creational.prototype.framework;

import java.util.HashMap;

public class Manager {

    private HashMap showcase = new HashMap();

    public void register(String name, Product prototype) {
        showcase.put(name, prototype);
    }

    public Product create(String prototypeName) {
        Product p = (Product) showcase.get(prototypeName);
        return p.createClone();
    }
}

3. UnderlinePenクラス

Productインターフェースを実装するクラスである。このクラスは「文字に下線を引く」クラスになる。

UnderlinePen.java

package com.devkuma.designpattern.creational.prototype.product;

import com.devkuma.designpattern.creational.prototype.framework.Product;

public class UnderlinePen implements Product {

    private char underlineChar;

    public UnderlinePen(char underlineChar) {
        this.underlineChar = underlineChar;
    }

    public void use(String s) {

        int length = s.getBytes().length;

        System.out.println(s);

        for (int i = 0; i < length; i++) {
            System.out.print(underlineChar);
        }

        System.out.println();
    }

    public Product createClone() {
        Product p = null;
        try {
            p = (Product) clone();
        } catch (CloneNotSupportedException e) {
            // オブジェクトのクラスがCloneableインターフェースを実装していない場合にthrowされる例外。
            e.printStackTrace();
        }
        return p;
    }
}

4. MessageBoxクラス

Productインターフェースを実装するクラスである。このクラスは「文字を囲む」クラスになる。

MessageBox.java

package com.devkuma.designpattern.creational.prototype.product;

import com.devkuma.designpattern.creational.prototype.framework.Product;

public class MessageBox implements Product {

    private char decoChar;

    public MessageBox(char decoChar) {
        this.decoChar = decoChar;
    }

    public void use(String s) {

        int length = s.getBytes().length;

        for (int i = 0; i < length + 2; i++) {
            System.out.print(decoChar);
        }

        System.out.println();
        System.out.println(decoChar + s + decoChar);

        for (int i = 0; i < length + 2; i++) {
            System.out.print(decoChar);
        }

        System.out.println();
    }

    public Product createClone() {
        Product p = null;
        try {
            p = (Product) clone();
        } catch (CloneNotSupportedException e) {
            // オブジェクトのクラスがCloneableインターフェースを実装していない場合にthrowされる例外。
            e.printStackTrace();
        }
        return p;
    }
}

5. Mainクラス

メイン処理を実行するクラスである。

Main.java

package com.devkuma.designpattern.creational.prototype;

import com.devkuma.designpattern.creational.prototype.framework.Manager;
import com.devkuma.designpattern.creational.prototype.framework.Product;
import com.devkuma.designpattern.creational.prototype.product.MessageBox;
import com.devkuma.designpattern.creational.prototype.product.UnderlinePen;

public class Main {
    public static void main(String[] args) {

        Manager manager = new Manager();
        UnderlinePen upen = new UnderlinePen('~');
        MessageBox mbox = new MessageBox('*');
        MessageBox pbox = new MessageBox('+');
        manager.register("strong message", upen);
        manager.register("warning box", mbox);
        manager.register("slash box", pbox);

        Product p1 = manager.create("strong message");
        p1.use("Hello world");
        System.out.println();
        Product p2 = manager.create("warning box");
        p2.use("Hello world");
        System.out.println();
        Product p3 = manager.create("slash box");
        p3.use("Hello world");
    }
}

6. 実行結果

Hello world
~~~~~~~~~~~

*************
*Hello world*
*************

+++++++++++++
+Hello world+
+++++++++++++

Prototypeパターンのメリット

サンプルプログラムでは比較的単純な場合だったが、インスタンスを生成するうえで複雑な処理が必要だったり、時間がかかる処理が必要だったりすることもある。インスタンスを生成するたびにnew Xxx()を使うのは非常に非効率である。
Prototypeを作ってコピーすれば、簡単にインスタンスを生成できる。

Design Pattern | Singleton Pattern(シングルトンパターン)

kc@example.com (kc kim) — Thu, 13 May 2021 09:10:45 +0900

Singletonパターンとは?

Singleton(シングルトン)とは、1つの要素だけを持つ集合という意味である。
Singletonパターンは、インスタンスが1つだけ存在することを保証する方式である。
Singletonパターンは、プログラム内でインスタンスを一度だけ生成したいときに使われる。
グローバル変数を使わずにオブジェクトを1つだけ生成し、生成されたオブジェクトをどこからでも参照できるようにするパターンである。
プログラム全体で使われる設定情報値も、Singletonパターンを使って1つだけ生成し、情報を共有するために必要である。
例えば、システム設定を表すクラス、ウィンドウシステムを表すクラスなどが挙げられる。
GoFデザインパターンでは、生成に関するデザインパターンに分類される。

Singletonパターンのサンプルプログラム

シングルトンインスタンスを生成するプログラムである。

Class Diagram

1. Singletonクラス

唯一のインスタンスを返すクラスである。
Singletonクラスのコンストラクタはprivateに指定する。これはSingletonクラスの外からコンストラクタを呼び出せないようにするためである。

Singleton.java

package com.devkuma.designpattern.creational.singleton.ex1;

public class Singleton {

    private static Singleton singleton = new Singleton();

    private Singleton() {
        System.out.println("인스턴스를 생성하였습니다.");
    }

    public static Singleton getInstance() {
        return singleton;
    }
}

2. Mainクラス

メイン処理を実行するクラスである。

Main.java

package com.devkuma.designpattern.creational.singleton.ex1;

public class Main {
    public static void main(String[] args) {
        Singleton obj1 = Singleton.getInstance();
        Singleton obj2 = Singleton.getInstance();
        if (obj1 == obj2) {
            System.out.println("obj1와 obj2는 동일한 인스턴스입니다.");
        } else {
            System.out.println("obj1와 obj2는 동일한 인스턴스가 아닙니다.");
        }
    }
}

3. 実行結果

인스턴스를 생성하였습니다.
obj1와 obj2는 동일한 인스턴스입니다.

Singletonパターンのメリット

Singletonパターンはインスタンス数に制限を設けている。
インスタンスが複数存在すると、インスタンス同士が互いに影響し、予期しないバグを作る可能性がある。
しかし、インスタンスが1つだけである保証があれば、その前提条件でプログラミングできる。

synchronizedを使用したSingletonパターン

synchronizedを使用したSingletonパターンのプログラム例

複数のオブジェクトから同時にアクセスできるため、synchronizedを宣言すればスレッドセーフになる。

package com.devkuma.designpattern.creational.singleton.ex2;

public class SynchronizedSingleton1 {

    private static Singleton1 instance;

    /**
     * アクセスできないコンストラクタ
     */
    private SynchronizedSingleton1() {
    }

    public static synchronized Singleton1 getInstance() {
        if (instance == null) {
            instance = new Singleton1();
        }
        return instance;
    }

    public static void main(String[] args) {

        Singleton1 singleton1 = Singleton1.getInstance();
        Singleton1 singleton2 = Singleton1.getInstance();

        System.out.println(singleton1);
        System.out.println(singleton2);
    }
}

synchronizedの性能を改善したSingletonパターンのプログラム例

同期化によって性能関連の問題が発生する可能性があるため、以下のようなコードを書いて最初の1回だけ同期化することで性能を向上できる。

volatile: スレッド環境で1つの変数が正しく一度に動作することを保証するキーワード。

package com.devkuma.designpattern.creational.singleton.ex2;

public class SynchronizedSingleton2 {

    private volatile static Singleton2 instance;

    /**
     * アクセスできないコンストラクタ
     */
    private SynchronizedSingleton2() {
    }

    public static Singleton2 getInstance() {
        if (instance == null) {
            // 最初の1回だけインスタンスが生成される。
            synchronized (Singleton2.class) {
                if (instance == null) {
                    instance = new Singleton2();
                }
            }
        }
        return instance;
    }

    public static void main(String[] args) {

        Singleton2 singleton1 = Singleton2.getInstance();
        Singleton2 singleton2 = Singleton2.getInstance();

        System.out.println(singleton1);
        System.out.println(singleton2);
    }
}

JUnit 5基本テスト - @Test, @DisplayName, @Disabled

kc@example.com (kc kim) — Fri, 09 Dec 2022 00:41:00 +0900

失敗、成功テスト

簡単に成功するテストケースと失敗するテストケースを作成する。

package com.devkuma.junit5.basic;

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

public class SuccessFailTest {

    @Test
    void success() {
        Assertions.assertEquals(3, 3);
    }

    @Test
    void fail() {
        Assertions.assertEquals(3, 2);
    }
}

実行結果:

O success()
X fail()

@Testアノテーションが指定されたメソッドがテストメソッドである。
JUnit 4まではorg.junit.Testだったが、JUnit 5ではorg.junit.jupiter.api.Testを使用する。

テスト名を表示する `@DisplayName`

JUnit 5の@DisplayNameを使用すると、次のようにメソッド名を韓国語で書くのではなく、

@Test
public void 게시글저장() {
     // ... 省略 ...
}
...

次のように表記できる。

@Test
@DisplayName("게시글 저장")
public void savePost() {
     // ... 省略 ...
}

テストの無効化

@Disabledアノテーションを使用すると、テストメソッドを実行しないようにできる。

package com.devkuma.junit5.basic;

import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;

public class DisabledTest {
    @Test
    void test1() {
        System.out.println("test1()");
    }

    @Test
    @Disabled
    void test2() {
        System.out.println("test2()");
    }
}

実行結果:

test1()

@Disabledはメソッドだけでなくクラスにも指定できる。その場合、テストクラス内のすべてのテストメソッドが実行されなくなる。

JUnit 5ライフサイクル - @BeforeAll, @BeforeEach, @AfterAll, @AfterEach

kc@example.com (kc kim) — Thu, 22 Sep 2022 06:56:00 +0900

`@BeforeAll`

@BeforeAllが宣言されたメソッドは、テストクラスのすべてのテストメソッドが実行される前に1回だけ実行される。データベース接続の設定や組み込みサーバーの起動など、テストクラスに対して一度だけ行う重い処理で使用する。メソッドシグネチャには必ずstaticを宣言する。

@BeforeAll
static void runOnceBeforeAllTests() {
    System.out.println("@BeforeAll executed \n");
}

`@BeforeEach`

@BeforeEachが宣言されたメソッドは、各テストメソッドの実行前に実行される。

@BeforeEach
void runBeforeEveryTest() {
  System.out.println("@BeforeEach executed");
}

`@AfterEach`

@AfterEachが宣言されたメソッドは、各テストメソッドの実行後に実行される。

@AfterEach
void runAfterEveryTest() {
    System.out.println("@AfterEach executed \n");
}

`@AfterAll`

@AfterAllが宣言されたメソッドは、テストクラスのすべてのテストメソッドが実行された後に1回だけ実行される。通常は@BeforeAllで行った設定の後始末、たとえばデータベース接続のクローズや組み込みサーバーの終了に使う。メソッドシグネチャには必ずstaticを宣言する。

@AfterAll
static void runOnceAfterAllTests() {
    System.out.println("@AfterAll executed");
}

実行順序

ライフサイクルの順序は、@BeforeAll、各テストごとの@BeforeEach、@Test、@AfterEach、最後に@AfterAllである。

参考

Junit5 Test Lifecycle @BeforeAll @BeforeEach @AfterAll @AfterEach | CODINGEEK

JUnit 5テスト実行順序 - メソッド名、@Order、ランダム

kc@example.com (kc kim) — Fri, 09 Dec 2022 08:06:00 +0900

テスト実行順序

デフォルトでは、JUnit 5のテストメソッド実行順序は意図的に明確でないアルゴリズムで決定される。完全なランダムではないが、推測して依存すべきではない。本来の単体テストは実行順序に依存しないことが望ましい。

ただし、結合テストや機能テストでは実行順序が重要になる場合がある。そのような場合のために、JUnitにはテスト実行順序を制御する仕組みが用意されている。

デフォルト順序

順序指定なしでテストを実行すると、メソッド宣言順とは異なる順序で実行されることがある。

メソッド名順

テストクラスに@TestMethodOrder(MethodOrderer.MethodName.class)を指定すると、メソッド名順で実行できる。MethodOrdererは実行順序を制御し、MethodNameはメソッド名をjava.util.Comparatorで比較して並べ替える。

`@Order`による順序

@TestMethodOrder(MethodOrderer.OrderAnnotation.class)を使うと、@Orderアノテーションで順序を明示できる。@Orderが指定されていないメソッドには、デフォルトでInteger.MAX_VALUEが割り当てられる。

ランダム順序

@TestMethodOrder(MethodOrderer.Random.class)を使用すると、メソッドの実行順序がランダムになる。テスト間の隠れた依存関係を見つけるのに役立つ。

JUnit 5条件付きテスト - @EnabledOnOs, @EnabledOnJre, @EnabledIfEnvironmentVariable

kc@example.com (kc kim) — Fri, 09 Dec 2022 09:21:00 +0900

条件付きテスト

テストコードは、OS、Javaバージョン、システムプロパティ、環境変数などの条件に応じて実行可否を変えられる。

OSによるテスト

@EnabledOnOs、@DisabledOnOsを使うと、特定OSを条件に実行可否を設定できる。valueにはOSに定義された定数を指定する。

Javaバージョン

@EnabledOnJre、@DisabledOnJreを使うと、特定Javaバージョンを条件に実行可否を設定できる。valueにはJREに定義された定数を指定する。

システムプロパティ

@EnabledIfSystemProperty、@DisabledIfSystemPropertyを使うと、システムプロパティの値を条件に実行可否を設定できる。

namedには条件となるシステムプロパティ名を指定する。
matchesには条件となる値を正規表現で指定する。

環境変数

@EnabledIfEnvironmentVariable、@DisabledIfEnvironmentVariableを使うと、環境変数の値を条件に実行可否を設定できる。

namedには条件にする環境変数名を指定する。
matchesには条件となる値を正規表現で指定する。

JUnit 5タグフィルタリング - @Tag

kc@example.com (kc kim) — Thu, 15 Dec 2022 21:41:00 +0900

タグフィルタリング

テストに@Tagを指定すると、入力したタグ名に応じてテストを実行できる。

タグ指定

@Tagはテストクラスまたはメソッドに追加して、テストケースにタグを指定できる。1つのテストに複数のタグを付けることもできる。

ConsoleLauncherでの実行

ConsoleLauncherでは、--include-tagなどのCLIオプションで一致するタグ、または一致しないタグを対象にできる。

タグ式の例:

tag3: tag3を持つテストを実行する。
tag1 & tag3: 両方のタグを持つテストを実行する。
tag1 | tag2: どちらかのタグを持つテストを実行する。
!tag1 & tag3: tag1を持たず、tag3を持つテストを実行する。
( !tag1 & tag3 ) | tag4: 括弧で条件をまとめる。

タグ名はnullまたは空文字であってはならず、空白文字や制御文字、(、)、,、&、|、!などの予約文字を含めてはならない。

Gradleでの実行

Gradleでは、useJUnitPlatform内でタグフィルタリングを指定する。

test {
    useJUnitPlatform {
        includeTags "tag1 | !tag3"
    }
}

includeTagsまたはexcludeTagsで指定できる。タグ式では!、&、|演算子を使える。

IntelliJ IDEAでの実行

JUnitの実行構成を作成し、Tagsを選択してタグ名を指定する。するとIntelliJ IDEAは、そのタグに一致するテストだけを実行する。

JUnit 5動的テスト - @TestFactory

kc@example.com (kc kim) — Tue, 13 Dec 2022 10:37:44 +0900

動的テスト

@TestFactoryアノテーションを使うと、テストケースを動的に生成できる。@TestFactoryが指定されたメソッドは、DynamicNodeのコレクションを返す必要がある。厳密には、戻り値はCollection、Iterable、Iterator、Stream、または配列にできる。

Streamで返す場合はJupiterがclose()してくれるため、Files.lines()で生成したStreamも安全に利用できる。

DynamicNode自体は抽象クラスなので、実際にはDynamicTestまたはDynamicContainerを使用する。dynamicTest(String, Executable)はDynamicTestを生成し、第1引数はテスト名、第2引数はテスト内容である。

動的テストのライフサイクル

@BeforeEachと@AfterEachは、@TestFactoryが設定されたメソッドの前後に実行される。個々の動的テストの前後には実行されない。

動的テストをネスト構造にする

DynamicContainerを使用すると、動的テストをネスト構造にできる。コンテナには動的テストや別の動的コンテナを含められるため、階層的なテスト出力を作成できる。

JUnit 5繰り返しテスト - @RepeatedTest

kc@example.com (kc kim) — Sun, 11 Dec 2022 10:27:10 +0900

繰り返しテスト

メソッドに@RepeatedTestを指定すると、valueに指定した回数だけテストが繰り返される。

繰り返される各テストのデフォルト表示名は、repetition <現在の繰り返し回数> of <総繰り返し回数>になる。

表示名の指定

@RepeatedTestのname属性で、繰り返しテストの表示名を指定できる。表示名には専用プレースホルダーを使用できる。

displayName: テストメソッドの表示名。デフォルトはメソッド名で、@DisplayNameが指定されていればそちらが使われる。
currentRepetition: 現在の繰り返し回数。値は1から始まる。
totalRepetitions: 総繰り返し回数。

事前定義された長い表示名パターンは{displayName} :: repetition {currentRepetition} of {totalRepetitions}である。

繰り返し情報を受け取る

@RepeatedTestが付いたテストメソッドは、現在の繰り返し情報を持つRepetitionInfoオブジェクトを引数で受け取れる。getCurrentRepetition()とgetTotalRepetitions()を提供する。

RepetitionInfoは@BeforeEach、@AfterEachでも受け取れる。ただし通常の@Testメソッドが混在していると、そのテストではRepetitionInfoを解決できずランタイムエラーになる。

JUnit 5パラメータ化テスト - @ParameterizedTest

kc@example.com (kc kim) — Wed, 21 Sep 2022 16:37:00 +0900

概要

@ParameterizedTestを使用すると、1つのテストメソッドで複数のパラメータをテストできる。

依存関係の追加

@ParameterizedTestを使うには、junit-jupiter-paramsライブラリが必要である。

dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter-params:5.8.1'
}

`@ValueSource`

@ValueSourceはリテラル値の単一配列を指定でき、パラメータ化されたテスト呼び出しごとに単一の引数を提供する場合に使用する。

Null and Empty Sources

@NullSource、@EmptySourceは、それぞれパラメータにnullとemptyを渡す。@ValueSourceと組み合わせることもできる。

@NullAndEmptySourceは、@NullSourceと@EmptySourceを一緒に使いたい場合の合成ソースである。ここでも@ValueSourceを組み合わせられる。

`@EnumSource`

@EnumSourceは、列挙型の値をパラメータとして渡す場合に使用する。

`@MethodSource`

@MethodSourceは、メソッドを使ってパラメータを渡す場合に使用する。プロバイダメソッドはArgumentsのStreamを返せる。

参照

JUnit 5並列実行

kc@example.com (kc kim) — Mon, 19 Dec 2022 10:09:19 +0900

テストの並列実行

デフォルトでは、すべてのテストメソッドは単一スレッドで順次実行される。JUnit 5では設定によりテストを並列実行できる。

並列実行の有効化

クラスパスのルートにjunit-platform.propertiesを作成し、並列実行を有効にする。

/test/resource/junit-platform.properties

junit.jupiter.execution.parallel.enabled=true

この設定だけではテストメソッドは並列にならない。メソッドを並列実行するには、テストクラスに@Execution(ExecutionMode.CONCURRENT)を設定する。SAME_THREADは親と同じスレッドで実行し、デフォルト値である。

デフォルト実行モードの変更

次のプロパティを設定すると、メソッドのデフォルト実行モードが並列実行になる。

junit.jupiter.execution.parallel.enabled=true
junit.jupiter.execution.parallel.mode.default=concurrent

ただし、Lifecycle.PER_CLASSを指定したテストクラスや、MethodOrderer.Random以外の順序指定テストは、このデフォルト並列モードの例外になる。スレッドセーフで並列実行したい場合は、明示的に@Execution(ExecutionMode.CONCURRENT)を付ける。

最上位クラスのデフォルト変更

junit.jupiter.execution.parallel.mode.classes.default=concurrentは、最上位クラスのデフォルト実行モードだけを変更する。この設定では、異なるテストクラスは別スレッドで実行され、各クラス内のメソッドは順次実行される。

設定別の実行

junit.jupiter.execution.parallel.mode.defaultとjunit.jupiter.execution.parallel.mode.classes.defaultの組み合わせにより、4つの動作になる。

両方same_thread: クラスとメソッドを順次実行する。
メソッドsame_thread、クラスconcurrent: クラスごとに並列実行し、クラス内メソッドは順次実行する。
メソッドconcurrent、クラスsame_thread: クラス内メソッドは並列実行し、クラスは順次実行する。
両方concurrent: クラスとメソッドをすべて並列実行する。

並列数の変更

dynamic戦略では、junit.jupiter.execution.parallel.config.dynamic.factorに利用可能プロセッサ数を掛けて、並列実行スレッド数を決定する。

junit.jupiter.execution.parallel.enabled=true
junit.jupiter.execution.parallel.config.strategy=dynamic
junit.jupiter.execution.parallel.mode.default=concurrent
junit.jupiter.execution.parallel.config.dynamic.factor=2

factorには小数も指定できる。JUnitは内部でBigDecimalを使い、計算結果をintへ変換する。

固定値を使う場合はfixedを指定し、junit.jupiter.execution.parallel.config.fixed.parallelismで並列数を指定する。

junit.jupiter.execution.parallel.enabled=true
junit.jupiter.execution.parallel.config.strategy=fixed
junit.jupiter.execution.parallel.mode.default=concurrent
junit.jupiter.execution.parallel.config.fixed.parallelism=6

任意にカスタマイズする場合はParallelExecutionConfigurationStrategyを実装し、junit.jupiter.execution.parallel.config.custom.classで指定する。

排他制御

排他制御は、共有リソースへ複数テストが同時アクセスしても問題が起きないようにする制御である。クラスまたはメソッドに@ResourceLockを付ける。同じロックキーを持つテストは同期される。

アクセスモード

@ResourceLockはResourceAccessModeによるアクセスモードをサポートする。

先行している処理	後から発生した処理	後から発生した処理
READ	READ	実行可能
READ	READ_WRITE	待機
READ_WRITE	READ	待機
READ_WRITE	READ_WRITE	待機

READだけなら並列実行可能だが、READ_WRITEがある場合は排他制御される。データを読むだけのテストにはREAD、更新するテストにはREAD_WRITEを指定する。

JUnit 5拡張モデル

kc@example.com (kc kim) — Mon, 26 Dec 2022 10:10:31 +0900

拡張モデル

JUnit Jupiterには拡張モデルという仕組みが用意されており、拡張機能を簡単に導入できる。

基本拡張モデル

拡張機能を作るには、Extensionインターフェース、またはそのサブインターフェースを実装する。Extension自体はマーカーインターフェースであり、メソッドは定義されていない。

マーカーインターフェースとは、通常のインターフェースと同じだがメソッドを宣言しないインターフェースである。JavaではSerializable、Cloneable、EventListenerなどが代表例で、多くの場合は単純な型チェックに使われる。

拡張ポイントはExtensionのサブインターフェースとして提供され、BeforeEachCallbackやAfterEachCallbackなどがある。

拡張クラスをテストに適用するには@ExtendWithを使用する。クラスに指定すればクラス内の各テストに適用され、メソッドに指定すればそのメソッドだけに適用される。

拡張ポイント

JUnit Jupiterには、実行条件、テストインスタンス生成、後処理、パラメータ解決、ライフサイクルコールバック、テスト結果監視、例外処理、テストテンプレート、手続き的登録、自動登録、データ共有などの拡張ポイントがある。

サポートクラス

拡張クラスを実装するとき、共通操作や例外処理を簡潔にするユーティリティクラスが提供されている。これらは第三者が独自のTestEngineや拡張機能を作るための公開サポートAPIなので、安心して使用できる。

テスト実行条件の制御

ExecutionConditionを実装し、evaluateExecutionCondition(ExtensionContext)からConditionEvaluationResultを返す。戻り値によって対象テストを有効にするか無効にするかを制御する。このコールバックは対象テストが評価されるたびに呼び出される。

テストインスタンス生成

TestInstanceFactoryを実装すると、テストインスタンスの生成方法をカスタマイズできる。createTestInstance()は各テストメソッドの実行前に呼び出され、リフレクション支援機能を使ってオブジェクトを生成できる。

テストインスタンス生成後の初期化

TestInstancePostProcessorを実装すると、生成されたテストインスタンスを初期化できる。依存性注入や初期化メソッド呼び出しに利用できる。

パラメータ解決

ParameterResolverを実装すると、テストメソッド、ライフサイクルメソッド、コンストラクタ、動的テストなどへ引数を提供できる。supportsParameter()で対象パラメータを判定し、resolveParameter()で実際の値を返す。Javaの引数名を取得するには、コンパイル時に-parametersオプションが必要である。

ライフサイクルコールバック

ライフサイクルコールバックインターフェースを使うと、全テスト前、各テスト前、テスト実行前、テスト実行後、各テスト後、全テスト後などのJUnitライフサイクルに処理を差し込める。

テスト結果に応じた処理

TestWatcherを実装すると、成功、失敗、中止、無効化などのテスト結果に反応できる。各メソッドは空実装のdefaultメソッドで、AfterEachCallbackの後に実行される。

テストで発生した例外処理

TestExecutionExceptionHandlerを実装すると、テストメソッドから投げられた例外を処理できる。アサーションエラーも対象になるため注意が必要である。

ライフサイクルメソッドの例外処理

LifecycleMethodExecutionExceptionHandlerを使うと、@BeforeAll、@BeforeEach、@AfterEach、@AfterAllなどのライフサイクルメソッドで発生した例外を処理できる。これはテスト実行中の例外を扱うTestExecutionExceptionHandlerとは別である。

同じテストを異なるコンテキストで実行

@TestTemplateとTestTemplateInvocationContextProviderを使うと、同じテストを異なる呼び出しコンテキストで実行できる。supportsTestTemplate()で対応可否を判断し、provideTestTemplateInvocationContexts()でコンテキストを提供する。各コンテキストは表示名や追加拡張を定義できる。

拡張機能の手続き的登録

@RegisterExtensionは、テストクラスのフィールドを通じて拡張機能を登録する。これにより拡張インスタンスの設定を動的に指定できる。staticフィールドはクラスレベル拡張を登録できるが、インスタンスフィールドではBeforeAllCallbackなど一部のクラスレベルコールバックを利用できない。

ServiceLoaderによる自動登録

拡張機能はJavaのServiceLoaderで自動登録できる。/META-INF/services/org.junit.jupiter.api.extension.Extensionを作成し、拡張実装クラスを列挙する。自動検出は次の設定で有効にする。

junit.jupiter.extensions.autodetection.enabled=true

Extension間のデータ共有

テストが並列実行される可能性がある場合、拡張のインスタンスフィールドで状態を共有するのは避ける。同じ拡張インスタンスが複数テストで再利用されるためである。代わりにExtensionContext.Storeを使用する。

StoreはExtensionContextからNamespace付きで取得する。名前空間を分けることで、同じキーを使う複数拡張の衝突を防げる。すべての拡張で共有したい場合だけNamespace.GLOBALを使う。

Storeのライフサイクルと検索

Storeのライフサイクルは、取得元のExtensionContextと同じである。メソッドレベルのコンテキストには親となるクラスレベルのコンテキストがあり、親コンテキストのStoreに保存した情報は子コンテキストからも参照できる。

ライフサイクル終了時の処理

Storeに保存するオブジェクトはExtensionContext.Store.CloseableResourceを実装できる。対応するStoreのライフサイクルが終了するとclose()が自動的に呼ばれるため、後片付け処理に使える。

JUnit 5メタアノテーション

kc@example.com (kc kim) — Sat, 07 Jan 2023 06:36:31 +0900

メタアノテーション

JUnit Jupiterはメタアノテーションの仕組みをサポートしている。つまり、任意のアノテーションを組み合わせた独自アノテーションを定義できる。

同じアノテーションの組み合わせを複数箇所で使う場合、それらを1つのカスタムアノテーションにまとめることで再利用性を高められる。

また、@ExtendWithで拡張クラスのClassオブジェクトを直接指定する代わりに独自アノテーションを使えるため、テストを特定実装から分離できる利点がある。

一般的な流れは、まずParameterResolverを実装し、次に@ExtendWith(MyParameterResolver.class)を付けたカスタムアノテーションを作成することだ。テストはそのカスタムアノテーションを使い、解決されたメソッド引数を受け取れる。

JUnit 5検証 - Assertion

kc@example.com (kc kim) — Thu, 15 Dec 2022 10:59:01 +0900

Assertion

JUnit 5はAssertionsというアサーションクラスを提供する。Assertionは、提供されるメソッドを使ってテストで検証したい値や動作を確認する機能である。

値検証Assertion

JUnitには基本的なアサーションメソッドが用意されている。

`assertEquals`

assertEquals(expected, actual, {message})は、実際の値が期待値と同じかを確認する。

`assertNull(actual)`

assertNull(actual, {message})は、値がnullかどうかを確認する。

`assertNotNull(actual)`

assertNotNull(actual, {message})は、値がnullではないかを確認する。

`assertTrue(boolean)`

assertTrue(actual, {message})は、条件がtrueかを確認する。

`assertFalse(boolean)`

assertFalse(actual, {message})は、条件がfalseかを確認する。

便利なAssertion

値検証のためのメソッド以外にも、便利なメソッドが用意されている。

`assertAll(executable...)`

assertAllは複数のアサーションをまとめて実行する。通常のアサーションを連続して書くと、前のアサーションが失敗した時点で次のテストは実行されないため、後続の失敗が分からない。assertAllを使うと、全体の結果を確認できる。

`assertThrows(expectedType, executable)`

assertThrowsは例外が発生するかを確認できる。返された例外を使って、例外メッセージが同じかどうかも確認できる。

`assertTimeout(duration, executable)`

assertTimeoutは、指定時間内に実行が完了するかを確認する。第2引数のラムダ式が終了するとテストも終了する。

`assertTimeoutPreemptively(duration, executable)`

assertTimeoutPreemptivelyも指定時間内に実行が完了するかを確認する。assertTimeoutとの違いは、assertTimeoutは処理終了まで待つのに対し、assertTimeoutPreemptivelyは指定時間を過ぎるとテストを直ちに終了する点である。

注意点

第2引数のラムダ式のロジックは別の`Thread`で実行されるため注意して使う必要がある。たとえばDatabaseのトランザクションコードがある場合、ロールバックされないことがある。

他のAssertionライブラリ

JUnit 5では他のアサーションライブラリも使用できる。AssertJやHamcrestなどを依存ライブラリに追加すれば、JUnit 4のときと同じように利用できる。

AssertJ

AssertJはメソッドチェーンをサポートしているため、よりきれいで読みやすいテストコードを書ける。使用するにはorg.assertj:assertj-coreをテスト依存関係に追加する。

JUnitでprivateメソッドをテストする方法

kc@example.com (kc kim) — Sun, 18 Apr 2021 18:20:30 +0900

概要

Javaの単体テストではJUnitがよく使われる。publicメソッドについてはテストコードを書くが、privateやprotectedメソッドのテストはおろそかになりがちである。

ホワイトボックステストはプログラマーの責務と考えられるため、すべてのコードをテストできるようにする必要がある。ここでは、すべてのメソッドをテストする方法を説明する。

テスト対象ソースコード

まず、テスト対象となる簡単なクラスを作成する。例ではpublicな加算メソッド、protectedな減算メソッド、privateな乗算メソッドを持つ。

publicメソッドのテスト

通常のテストケースでは、インスタンスを作成してpublicメソッドを直接呼び出せる。これは一般的なJUnitのテスト方法である。

protected、privateメソッドのテスト

protectedやprivateメソッドは通常のインスタンス呼び出しでは直接呼べないため、Javaのリフレクションを使用する。

Sample sample = new Sample();
Method method = Sample.class.getDeclaredMethod("{メソッド名}", {引数1}, {引数2}...);
method.setAccessible(true);
int actual = ({戻り型}) method.invoke(<インスタンス>, {引数1}, {引数2}...);

どのクラスにも存在するclass変数を使い、getDeclaredMethod()でテスト対象メソッドを取得する。返されたメソッドにsetAccessible(true)を設定して外部からアクセスできるようにし、method.invoke()で実行する。

結論

リフレクションを使うことで、直接呼び出せないメソッドもテストできる。バグはプログラマーにとって最大の敵なので、可能な限り取り除くように努めよう。

Mockitoとは？

kc@example.com (kc kim) — Wed, 21 Sep 2022 18:27:00 +0900

Mockito

Mockito(モキート)は、JavaテストでMock(モック)オブジェクトを簡単に作成、管理、検証できる方法を提供するフレームワークである。

Mockはテスト用の偽物オブジェクトである。Mockitoでは、指定クラスのMockを作成し、任意のメソッドをstubとして指定値を返すようにしたり、Mockのメソッドが期待どおりに呼び出されたかを検証したりできる。Mock動作を型安全に定義できる点が大きな特徴である。

HelloWorld

Mockitoを使うには、たとえばorg.mockito:mockito-coreをテスト依存関係に追加する。そしてmock()でMockオブジェクトを作成し、when(...).thenReturn(...)で動作を定義する。

List<String> mock = mock(List.class);
when(mock.get(0)).thenReturn("Hello Mockito!");

ここではjava.util.ListのMockを作成し、get(0)を実行すると"Hello Mockito!"を返すように定義している。

Mockの基本動作

stubされていないMockメソッドはデフォルト値を返す。プリミティブ値はゼロ相当、コレクションは空コレクション、オブジェクト参照は一般的にnullを返す。

`when`でStubを作る

Mockメソッドが返す値は次の形式で指定できる。

when(<stubにしたいメソッド呼び出し>).thenReturn(<メソッド戻り値>)

一度stub化されたメソッドは、別のstubで上書きしない限り常に同じ値を返す。

呼び出しごとに異なる値を返す

可変長引数のthenReturn(T...)を使うと、呼び出しごとに異なる値を返せる。指定数以上に呼び出された場合は、最後に指定した値が返され続ける。

例外を発生させる

thenThrow(Throwable...)を使うと、stubが例外を投げるようにできる。可変長引数を使えば、呼び出しごとに異なる例外を発生させられ、指定した例外が尽きると最後の例外が投げ続けられる。

戻り値と例外の組み合わせ

Mockitoでは、連続呼び出しに対して戻り値と例外を組み合わせることもできる。

任意の引数にマッチさせる

ArgumentMatchersのanyInt()、anyList()、any()などを使うと、任意の引数に対するstubを定義できる。

複数引数のメソッドで1つでもmatcherを使う場合、他のすべての引数もmatcherで指定する必要がある。特定値を指定したい場合はeq()を使う。

カスタム引数マッチング

組み込みmatcherだけでは足りない場合、カスタムmatcherを使用できる。

Stub内で任意処理を実行する

stubで任意の処理を実行したい場合はthenAnswer()を使う。MockitoにはAnswer1からAnswer6までの型付きヘルパーもある。ただし複雑なstubはテストの意味を分かりにくくし、保守性を下げるため乱用は避ける。公式文書でも可能な限りthenReturn()とthenThrow()を推奨している。

`void`メソッドのstub

戻り値がvoidのメソッドで例外を発生させたい場合は、doThrow()から始まるstub化方法を使用する。

メソッドが呼び出されたか確認する

verify()を使うと、メソッドが呼び出されたかを確認できる。検証には引数も含まれる。

Mockitoでは次のことを検証できる。

メソッドが一致する引数で呼び出されたか。
メソッドが何回呼び出されたか。
少なくとも、または最大で指定回数呼び出されたか。
一度も呼び出されていないか。
InOrderによる呼び出し順序。
複数Mockにまたがる呼び出し順序。
ArgumentCaptorによる実際に渡された引数。

Spy - スパイ

Spyは実オブジェクトを基に作成される。stubされていないSpyメソッドは実メソッドを実行する。Spyは元オブジェクトのコピーを基に作成されるため、Spyと元オブジェクトの変更が常に共有されるわけではない。

Spyをstub化するとき、when(spy.method())はstub定義時に実メソッドを呼び出すことがある。実メソッドを呼び出したくない場合はdoReturn().when(spy).method()を使う。実メソッドを実行せず例外を投げるstubにしたい場合はdoThrow()を使う。

Mockitoはspy(Class)で抽象クラスのSpyも作成できる。ただし対象クラスにはデフォルトコンストラクタが必要である。

他オブジェクトへの委譲

AdditionalAnswers.delegatesTo()を使うと、別オブジェクトへ呼び出しを委譲するMockまたはSpy風オブジェクトを作成できる。委譲先オブジェクトはMock対象型を継承している必要はない。

Serializable可能なMock

withSettings().serializable()を使うと、SerializableなMockを作成できる。

One-linerでMockとStubを作成

MockitoではMock作成とstub定義をコンパクトに1行で書ける。ただし、テストの可読性を保つため使いすぎには注意する。

アノテーションで定義する

Mockitoは@Mock、@Spy、@Captorなどのフィールドアノテーションをサポートする。Mockitoのアノテーション初期化機能で初期化する。JUnit 5ではmockito-junit-jupiterを追加してMockitoExtensionを使い、メソッド引数としてMockを受け取ることもできる。

inline mock maker

inline mock makerを導入すると、通常のMockitoではできないfinalクラスのMock化やstaticメソッドのstub化などが可能になる。依存関係にorg.mockito:mockito-inlineを追加する。

inline mock makerにより、次のことができる。

finalクラスやfinalメソッドのMock/stub化。
Mockito.mockStatic(Class)によるstaticメソッドのstub化。
mockConstruction()によるコンストラクタからのMock返却。

コンストラクタMockは、返されたMockedConstructionがcloseされるまで有効である。stubと検証は通常のMockito APIであるwhen()やverify()を使用する。

Mock化できないクラス定義

Mockitoには、Mock化すべきでないクラスを示す@DoNotMockがある。そのようなクラスをMock化しようとするとMockitoは失敗し、実インスタンスを作成するよう求める。

参照

WebClientテスト - MockWebServerで外部API呼び出しメソッドをテストする

kc@example.com (kc kim) — Sat, 17 Dec 2022 16:31:28 +0900

概要

最近のほとんどのサービスではREST APIを呼び出すことが想定される。SpringはRESTクライアント構築のためにいくつかの選択肢を提供しており、WebClientを推奨している。

ここでは、WebClientを使ってAPIを呼び出すサービスを単体テストする方法を説明する。

MockWebServerとは？

Squareチームが作成したMockWebServerは、HTTP Requestを受け取りResponseを返す小さくシンプルなWebサーバーである。

WebClientやRestTemplateなどのClientを使ってHTTPを呼び出すメソッドのテストコードを書くとき、このMockWebServerを呼び出すようにすれば簡単にテストコードを書ける。Spring Teamもこの種のテストではMockWebServerの使用を推奨しているという。

簡単なWebClientプロジェクト作成

MockWebServerを使う前に、まずテスト対象となる簡単なWebClientプロジェクトを作成する。サンプルではSpring Initializrを使い、Java 11、Gradle、Spring Boot 2.7.6、webflux依存関係でプロジェクトを生成する。

データを受け取るDTOオブジェクトを作成し、WebClientで/users/{id}を呼び出してMono<User>を返すサービスコードを作成する。

MockWebServerの適用

依存関係の追加

MockWebServerを使用するため、テスト依存関係を追加する。

dependencies {
    testImplementation 'com.squareup.okhttp3:mockwebserver'
}

テストコードにMockWebServerを追加

テストコードでは、@BeforeAllでMockWebServerオブジェクトを作成して起動し、@AfterAllで終了する。

サービスにWebClientを生成して渡す

MockWebServerのポートを使ったbase URLでWebClientを作成し、サービスへ渡す。

@BeforeEach
void initialize() {
    final String baseUrl = String.format("http://localhost:%s", mockWebServer.getPort());
    final WebClient webClient = WebClient.create(baseUrl);
    userService = new UserService(webClient);
}

このようにすると、テスト実行時に実際の外部URLではなくMockWebServerが呼び出される。

任意のResponseを作成

MockResponseを作成し、bodyとheaderを設定してenqueueに入れる。MockWebServerはenqueueされた順番でレスポンスを返す。

Requestのチェック

レスポンス値だけでなく、takeRequest()を使ってリクエスト内容も確認できる。

final RecordedRequest recordedRequest = mockWebServer.takeRequest();
assertAll(
        () -> assertEquals("GET", recordedRequest.getMethod()),
        () -> assertEquals("/users/3", recordedRequest.getPath())
);

参照

上記のサンプルコードはGitHubで確認できる。

devkuma – Java

JUnit

JUnit 5の適用方法

ビルド環境

テストコードの作成

Spring Bootでの適用方法

JUnit 5概要

JUnitとは？

単体テストと機能テスト

単体テスト

機能テスト

JUnit 5サポート

JUnit 5の構成

関連リンク

Design Pattern | Abstract Factory Methods

Abstract Factoryパターンとは?

Abstract Factoryパターンのサンプルプログラム

1. Factoryクラス

2. Itemクラス

3. Linkクラス

4. Trayクラス

5. Pageクラス

6. ListFactoryクラス

7. ListLinkクラス

8. ListTrayクラス

9. ListPageクラス

10. Mainクラス

11. 実行結果

Abstract Factoryパターンのメリット

JUnit 5テスト実行方法 - ConsoleLauncher, Gradle

ConsoleLauncherの使い方

テスト実行方法

テスト実行出力

コマンドヘルプ

Gradleでのテスト実行

Gradle設定

テストコード実行

Design Pattern | Builder Pattern(ビルダーパターン)

Builderパターンとは?

Builderパターンのサンプルプログラム

1. Builderクラス

2. Guideクラス

3. TextBuilderクラス

4. HTMLBuilderクラス

5. Mainクラス

6. 実行結果

7. Builderパターンのメリット

Design Pattern | Prototype Pattern(プロトタイプパターン)

Prototypeパターンとは?

Prototypeパターンのサンプルプログラム

1. Productインターフェース

2. Managerクラス

3. UnderlinePenクラス

4. MessageBoxクラス

5. Mainクラス

6. 実行結果

Prototypeパターンのメリット

Design Pattern | Singleton Pattern(シングルトンパターン)

Singletonパターンとは?

Singletonパターンのサンプルプログラム

1. Singletonクラス

2. Mainクラス

3. 実行結果

Singletonパターンのメリット

synchronizedを使用したSingletonパターン

synchronizedを使用したSingletonパターンのプログラム例

synchronizedの性能を改善したSingletonパターンのプログラム例

JUnit 5基本テスト - @Test, @DisplayName, @Disabled

失敗、成功テスト

テスト名を表示する @DisplayName

テストの無効化

JUnit 5ライフサイクル - @BeforeAll, @BeforeEach, @AfterAll, @AfterEach

@BeforeAll

@BeforeEach

@AfterEach

@AfterAll

実行順序

参考

JUnit 5テスト実行順序 - メソッド名、@Order、ランダム

テスト実行順序

テスト名を表示する `@DisplayName`

`@BeforeAll`

`@BeforeEach`

`@AfterEach`

`@AfterAll`

`@Order`による順序

`@ValueSource`

`@EnumSource`

`@MethodSource`

`assertEquals`

`assertNull(actual)`

`assertNotNull(actual)`

`assertTrue(boolean)`

`assertFalse(boolean)`