devkuma – Java

JUnit

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

How to Apply JUnit 5

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

Build Environment

In a Gradle environment, you need a build file like the following 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()
}

The dependency org.junit.jupiter:junit-jupiter-api is required.

When you create a project with an IDE, the directory structure looks like this.

.
├── 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

Writing Test Code

/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);
        }
    }
}

How to Apply It in Spring Boot

Since Spring Boot 2.2, JUnit 5 is provided by default. If you use JUnit 5, it is included in starter-test without separate configuration.

Spring Boot 2.2.x or later

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

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

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

What Is JUnit?

JUnit is a framework for unit testing in Java. It can create object instances, execute logic, compare actual results with expected values, and test file, network, or database interactions.

JUnit provides assertion-related methods that check whether a test result is true or false, null, or the same object. It also provides the @Test annotation to mark test methods, and lifecycle annotations such as Before and After to define behavior before and after tests.

JUnit is an open source testing framework for Java, developed by Erich Gamma, one of the GoF authors of “Design Patterns”, and Kent Beck, who is well known for XP. JUnit provides a simple way to express the intended behavior in code and verify that the code works as expected. Originally, JUnit could be used independently of IDEs and development tools, either from the command line or in a GUI environment.

Unit Tests and Functional Tests

Unit Tests

A unit test checks whether a basic unit of a program works correctly according to its internal design specification. In Java, the basic unit is a class, so you test whether the methods included in each class work correctly. Therefore, the scope of a unit test is very limited.

Functional Tests

A functional test checks whether the entire software works correctly. It treats the whole software system as a black box and tests each feature from the user’s point of view. Functional tests are usually performed by a separate test team and use tools and techniques different from those used during development.

JUnit 5 Support

JUnit 4
- Java 1.4 or later
JUnit 5
- JUnit 5 requires Java 1.8 or later

JUnit 5 Structure

JUnit 4 was an all-in-one structure, but JUnit 5 is divided into Platform, Jupiter, and Vintage.

Base module for running test frameworks
- JUnit Platform: Provides the foundation for running test frameworks on the JVM and also provides APIs for test development.
Concrete test framework modules
- JUnit Jupiter: Provides a TestEngine that combines the new programming model and extension model for JUnit 5 tests and extensions.
- JUnit Vintage: A TestEngine for running JUnit 4 and JUnit 3 tests for backward compatibility.

Design Pattern | Abstract Factory Methods

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

What Is the Abstract Factory Pattern?

Abstract Factory means an abstract factory.
Being abstract means focusing only on the interface without considering how it is concretely implemented.
The Abstract Factory pattern focuses on interfaces rather than the concrete implementation of parts. It assembles parts using only those interfaces and organizes them into products.
It creates products by combining related parts.
In GoF design patterns, it is classified as a creational design pattern.

Abstract Factory Pattern Example Program

This example program outputs a favorites list in HTML format.

Class Diagram

1. Factory Class

This class represents an abstract factory. It creates Link, Tray, and 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 Class

This class treats Link and Tray uniformly.

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 Class

Abstract part: a class that represents an HTML link.

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 Class

Abstract part: a class that collects Link and 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 Class

Abstract part: a class that represents an HTML page.

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 Class

This class represents a concrete factory. It creates ListLink, ListTray, and 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 Class

Concrete part: a class that represents an HTML link.

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 Class

Concrete part: a class that collects Link and 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 Class

Concrete part: a class that represents an HTML page.

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 Class

This is the class that executes the main processing.

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. Execution Result

The file generated by the program is shown below.

즐겨찾기.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>

Advantages of the Abstract Factory Pattern

For example, when adding a new concrete factory to the example program, you create subclasses of Factory, Link, Tray, and Page and implement each abstract method.
In other words, you only concretize the abstract parts held by the classes in the factory package. At this time, no matter how many concrete factories are added, there is no need to modify the abstract factory.

How to Run JUnit 5 Tests - ConsoleLauncher, Gradle

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

Using ConsoleLauncher

JUnit 5 provides a command-line tool called ConsoleLauncher. Because it is distributed as a JAR file, download it from the Maven Central Repository. In this example, version 1.9.1 was used.

Running Tests

Test classes are usually located under build/classes/java/test or target/test-classes.

Run all tests on the test classpath:

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

--classpath can be shortened to -cp. The standalone JAR already includes JUnit 5 classes, and -cp can additionally include dependencies used by the tests.

Run a specific class:

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

--select-class can be shortened to -c. You can also select a package with --select-package or filter class names with --include-classname and a regular expression.

Test Output

Test results are printed to the console. Successful tests, failed tests, failure details, container counts, and test counts are all included in the output.

Command Help

ConsoleLauncher provides many more options. Check them with:

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

Running Tests with Gradle

Most projects run tests through their build tool. Gradle supports JUnit 5 by default from Gradle 4.6.

Gradle Configuration

Gradle also supports other test frameworks such as JUnit 4 and TestNG. To use JUnit 5, explicitly declare useJUnitPlatform().

build.gradle

test {
    useJUnitPlatform()
}

Running Test Code

If all tests pass, Gradle reports BUILD SUCCESSFUL. If failures exist, the test task fails and Gradle prints the failing test names and the report path, such as build/reports/tests/test/index.html.

Static nested classes can be executed as tests, while ordinary inner classes are not run by default.

Design Pattern | Builder Pattern

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

What Is the Builder Pattern?

The word build means to build something large with structure.
When creating something with a complex structure, it is difficult to complete it all at once. First, each part that makes up the whole is created, and then it is assembled step by step.
The same construction process can create different representation objects.
Whether there are many or few parameters for the constructor, parameters are accepted one after another, and after all parameters are received, they are integrated and used at once.
The Builder pattern is a way to build instances that have structure.
In GoF design patterns, it is classified as a creational design pattern.

Builder Pattern Example Program

This example program outputs a document in plain text and HTML formats.

Class Diagram

1. Builder Class

This abstract class defines methods for composing a document.

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 Class

This class creates one document.

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 Class

This class creates a document as plain text.

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 Class

This class creates a document as an HTML file.

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 Class

This is the main class that runs the example program.

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. Execution Result

Text

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

- 일시
　- 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. Advantages of the Builder Pattern

In the example program, the Main class does not know how to build the document, that is, the methods of the Builder class. The Main class can build the document simply by calling the construct method of the Guide class.
The Guide class uses the Builder class to create the document, but it does not know which class it is actually using, whether TextBuilder or HtmlBuilder.
An instance of TextBuilder or an instance of HTMLBuilder can both be passed to Guide and still work correctly because the Guide class does not know the concrete class of the Builder class.
Because it does not know the concrete class, replacement is possible, and because replacement is possible, its value as a component increases.

Design Pattern | Prototype Pattern

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

What Is the Prototype Pattern?

The English word prototype means an original form or model.
The Prototype pattern does not create an instance from a class using new Xxx(). Instead, it creates another instance from an existing instance. In other words, it creates an instance by copying.
The work of making a copy is called clone.
In GoF design patterns, it is classified as a creational design pattern.

Prototype Pattern Example Program

This example program underlines or surrounds an input string.

Class Diagram

1. Product Interface

This interface defines the cloning method. It extends Java’s Cloneable interface.

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 Class

This class instructs and manages the creation of Products.

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 Class

This class implements the Product interface. It is a class that “underlines text.”

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) {
            // Exception thrown when the object's class does not implement the Cloneable interface.
            e.printStackTrace();
        }
        return p;
    }
}

4. MessageBox Class

This class implements the Product interface. It is a class that “surrounds text.”

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) {
            // Exception thrown when the object's class does not implement the Cloneable interface.
            e.printStackTrace();
        }
        return p;
    }
}

5. Main Class

This is the main class that executes the main processing.

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. Execution Result

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

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

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

Advantages of the Prototype Pattern

The example program is relatively simple, but creating an instance may require complex processing or time-consuming processing. Creating an instance with new Xxx() every time can be very inefficient.
By creating a prototype and copying it, instances can be created easily.

Design Pattern | Singleton Pattern

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

What Is the Singleton Pattern?

Singleton means a set that has only one element.
The Singleton pattern guarantees that only one instance exists.
The Singleton pattern is used when you want an instance to be created only once in a program.
It is a pattern that creates only one object without using global variables and allows the created object to be referenced from anywhere.
Configuration values used globally in a program also need the Singleton pattern to create only one object and share information.
Examples include classes that represent system settings or window systems.
In GoF design patterns, it is classified as a creational design pattern.

Singleton Pattern Example Program

This program creates a singleton instance.

Class Diagram

1. Singleton Class

This class returns the unique instance.
The constructor of the Singleton class is specified as private. This prevents the constructor from being called outside the Singleton class.

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 Class

This is the main class that executes the main processing.

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. Execution Result

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

Advantages of the Singleton Pattern

The Singleton pattern places a limit on the number of instances.
If multiple instances exist, they can affect each other and create unexpected bugs.
However, if there is a guarantee that only one instance exists, programming can be done based on that precondition.

Singleton Pattern Using synchronized

Example Program for Singleton Pattern Using synchronized

Because multiple objects can access it at the same time, declaring synchronized makes it thread-safe.

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

public class SynchronizedSingleton1 {

    private static Singleton1 instance;

    /**
     * Inaccessible constructor
     */
    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);
    }
}

Example Program for a Singleton Pattern with Improved synchronized Performance

Because synchronization can cause performance issues, the code below improves performance by synchronizing only once at first.

volatile: a keyword that guarantees a variable works correctly at once in a threading environment.

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

public class SynchronizedSingleton2 {

    private volatile static Singleton2 instance;

    /**
     * Inaccessible constructor
     */
    private SynchronizedSingleton2() {
    }

    public static Singleton2 getInstance() {
        if (instance == null) {
            // The instance is created only once at first.
            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 Basic Tests - @Test, @DisplayName, @Disabled

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

Failed and Successful Tests

The following example creates simple test cases that succeed and fail.

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

Execution result:

O success()
X fail()

A method annotated with @Test is a test method.
Up to JUnit 4, org.junit.Test was used, but JUnit 5 uses org.junit.jupiter.api.Test.

Displaying Test Names with `@DisplayName`

With JUnit 5 @DisplayName, you do not need to write method names in Korean like this:

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

You can write them as follows instead.

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

Disabling Tests

Using the @Disabled annotation prevents a test method from being executed.

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

Execution result:

test1()

@Disabled can be specified not only on methods but also on classes. In that case, all test methods in the test class are not executed.

JUnit 5 Lifecycle - @BeforeAll, @BeforeEach, @AfterAll, @AfterEach

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

`@BeforeAll`

A method annotated with @BeforeAll is executed exactly once before all test methods in the test class. It is used for heavy setup that should happen once per class, such as opening a database connection or starting an embedded server. The method signature must be static.

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

`@BeforeEach`

A method annotated with @BeforeEach is executed before each test method.

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

`@AfterEach`

A method annotated with @AfterEach is executed after each test method.

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

`@AfterAll`

A method annotated with @AfterAll is executed exactly once after all test methods in the test class. It is usually used to close resources opened in @BeforeAll, such as database connections or embedded servers. The method signature must be static.

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

Execution Order

The lifecycle order is @BeforeAll, then for each test @BeforeEach, @Test, @AfterEach, and finally @AfterAll.

Reference

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

JUnit 5 Test Execution Order - Method Name, @Order, Random

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

Test Execution Order

By default, JUnit 5 intentionally uses an algorithm whose order is not obvious. It is not truly random, but it should not be relied on. Original unit tests should not depend on execution order.

For integration tests or functional tests, however, execution order can matter. JUnit provides mechanisms to control test order for those cases.

Default Order

Without ordering annotations, tests may run in an order that differs from the method declaration order.

Method Name Order

Specify @TestMethodOrder(MethodOrderer.MethodName.class) on the test class to execute test methods in method-name order. MethodOrderer controls execution order, and MethodName sorts by comparing method names with java.util.Comparator.

Order with `@Order`

Using @TestMethodOrder(MethodOrderer.OrderAnnotation.class) lets you specify order with @Order. Methods without @Order are assigned Integer.MAX_VALUE by default.

Random Order

Using @TestMethodOrder(MethodOrderer.Random.class) executes methods in random order. This is useful for finding hidden dependencies between tests.

JUnit 5 Conditional Tests - @EnabledOnOs, @EnabledOnJre, @EnabledIfEnvironmentVariable

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

Conditional Tests

Test code can be enabled or disabled depending on conditions such as OS, Java version, system properties, or environment variables.

Tests by OS

Use @EnabledOnOs and @DisabledOnOs to run or skip tests for a specific OS. Specify an OS constant in value.

Java Version

Use @EnabledOnJre and @DisabledOnJre to run or skip tests for a specific Java version. Specify a JRE constant in value.

System Properties

Use @EnabledIfSystemProperty and @DisabledIfSystemProperty to control execution by system property values.

named specifies the system property name.
matches specifies the expected value as a regular expression.

Environment Variables

Use @EnabledIfEnvironmentVariable and @DisabledIfEnvironmentVariable to control execution by environment variable values.

named specifies the environment variable name.
matches specifies the expected value as a regular expression.

JUnit 5 Tag Filtering - @Tag

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

Tag Filtering

By specifying @Tag on tests, you can run tests according to the tag names you provide.

Assigning Tags

@Tag can be added to a test class or method to tag test cases. A single test can have multiple tags.

Running with ConsoleLauncher

ConsoleLauncher can target matching or non-matching tags with CLI options such as --include-tag.

Examples of tag expressions:

tag3: run tests with tag3.
tag1 & tag3: run tests that have both tags.
tag1 | tag2: run tests that have either tag.
!tag1 & tag3: run tests that do not have tag1 but have tag3.
( !tag1 & tag3 ) | tag4: group conditions with parentheses.

Tag names must not be null or empty, must not include whitespace or control characters, and must not include reserved characters such as (, ), ,, &, |, or !.

Running from Gradle

In Gradle, specify tag filtering inside useJUnitPlatform.

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

You can use includeTags or excludeTags. Tag expressions support !, &, and | operators.

Running from IntelliJ IDEA

Create a JUnit run configuration, choose Tags, and enter the tag name. IntelliJ IDEA then runs only the tests matching that tag.

JUnit 5 Dynamic Tests - @TestFactory

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

Dynamic Tests

You can dynamically generate test cases with the @TestFactory annotation. A method annotated with @TestFactory must return a collection of DynamicNode. Strictly speaking, the return value can be a Collection, Iterable, Iterator, Stream, or array.

If a Stream is returned, Jupiter closes it, so streams created by APIs such as Files.lines() can also be used safely.

DynamicNode is an abstract class, so in practice you use either DynamicTest or DynamicContainer. dynamicTest(String, Executable) creates a DynamicTest; the first argument is the test name and the second argument is the test body.

Dynamic Test Lifecycle

@BeforeEach and @AfterEach run before and after the method annotated with @TestFactory; they do not run before and after each individual dynamic test.

Creating Nested Dynamic Tests

Use DynamicContainer to create nested dynamic tests. A container can include dynamic tests and other dynamic containers, allowing hierarchical test output.

JUnit 5 Repeated Tests - @RepeatedTest

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

Repeated Tests

Annotating a method with @RepeatedTest repeats the test as many times as the specified value.

The default display name for each repeated execution is repetition <current repetition> of <total repetitions>.

Specifying the Display Name

The name attribute of @RepeatedTest lets you specify the display name for repeated tests. Placeholders can be used in the name.

displayName: Display name of the test method. The default is the method name, but @DisplayName takes precedence.
currentRepetition: Current repetition count, starting at 1.
totalRepetitions: Total repetition count.

The predefined long display pattern is {displayName} :: repetition {currentRepetition} of {totalRepetitions}.

Receiving Repetition Information

A test method annotated with @RepeatedTest can receive a RepetitionInfo object as an argument. It provides getCurrentRepetition() and getTotalRepetitions().

RepetitionInfo can also be received in @BeforeEach and @AfterEach. If ordinary @Test methods are mixed in, RepetitionInfo cannot be resolved for those tests and a runtime error occurs.

JUnit 5 Parameterized Tests - @ParameterizedTest

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

Overview

@ParameterizedTest lets one test method run with multiple parameters.

Adding Dependencies

To use @ParameterizedTest, add the junit-jupiter-params library.

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

`@ValueSource`

@ValueSource specifies a single array of literal values. It is used when each parameterized test invocation receives one argument.

Null and Empty Sources

@NullSource and @EmptySource provide null and empty values respectively. They can be combined with @ValueSource.

@NullAndEmptySource is a composed source used when both @NullSource and @EmptySource are needed. It can also be combined with @ValueSource.

`@EnumSource`

@EnumSource is used to pass enum values as parameters.

`@MethodSource`

@MethodSource is used when parameters are provided by a method. The provider method can return a Stream of Arguments.

References

JUnit 5 Parallel Execution

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

Parallel Test Execution

By default, all test methods run sequentially on a single thread. JUnit 5 can execute tests in parallel when configured.

Enabling Parallel Execution

Create junit-platform.properties at the classpath root and enable parallel execution.

/test/resource/junit-platform.properties

junit.jupiter.execution.parallel.enabled=true

This setting alone does not make test methods parallel. To run methods concurrently, set @Execution(ExecutionMode.CONCURRENT) on the test class. SAME_THREAD runs tests on the same thread as the parent and is the default.

Changing the Default Execution Mode

Set the following property to make the default method execution mode concurrent.

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

Some tests are excluded from this default concurrent mode, including test classes using Lifecycle.PER_CLASS and ordered tests except MethodOrderer.Random. If such tests are thread-safe and you still want them to run concurrently, explicitly add @Execution(ExecutionMode.CONCURRENT).

Changing the Top-Level Class Default

junit.jupiter.execution.parallel.mode.classes.default=concurrent changes only the default execution mode for top-level classes. In that configuration, different test classes can run on different threads while methods inside each class still run sequentially.

Execution by Setting

The combination of junit.jupiter.execution.parallel.mode.default and junit.jupiter.execution.parallel.mode.classes.default produces four patterns.

Both same_thread: classes and methods run sequentially.
Method same_thread, class concurrent: classes run in parallel, methods in each class run sequentially.
Method concurrent, class same_thread: methods inside a class run in parallel, classes run sequentially.
Both concurrent: classes and methods all run in parallel.

Changing Parallelism

With the dynamic strategy, junit.jupiter.execution.parallel.config.dynamic.factor multiplies the number of available processors to decide the number of parallel threads.

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

The factor can also be a decimal. JUnit uses BigDecimal internally and converts the calculated value to int.

For a fixed value, use fixed and specify 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

For custom parallelism, implement ParallelExecutionConfigurationStrategy and specify it with junit.jupiter.execution.parallel.config.custom.class.

Exclusive Control

Exclusive control prevents problems when multiple tests access a shared resource at the same time. Use @ResourceLock on a class or method. Tests with the same lock key are synchronized.

Access Modes

@ResourceLock supports access modes with ResourceAccessMode.

Previous process	Later process	Later process
READ	READ	Can run
READ	READ_WRITE	Waits
READ_WRITE	READ	Waits
READ_WRITE	READ_WRITE	Waits

READ can run in parallel with other reads, but READ_WRITE is exclusive. Use READ for tests that only read data and READ_WRITE for tests that update data.

JUnit 5 Extension Model

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

Extension Model

JUnit Jupiter provides an extension model that makes it easy to introduce extension features.

Basic Extension Model

To create an extension, implement the Extension interface or one of its subinterfaces. Extension itself is a marker interface and does not define methods.

A marker interface is an interface with no declared methods. Java examples include Serializable, Cloneable, and EventListener. They are commonly used for simple type checks.

Extension points are provided as subinterfaces of Extension, such as BeforeEachCallback and AfterEachCallback.

Use @ExtendWith to apply an extension class to a test class or test method. Applying it to a class affects each test in that class; applying it to a method affects only that method.

Extension Points

JUnit Jupiter provides extension points for execution conditions, test instance creation, post-processing, parameter resolution, lifecycle callbacks, test result watching, exception handling, test templates, programmatic registration, automatic registration, and data sharing.

Support Classes

When implementing extensions, JUnit provides utility classes that simplify common operations and exception handling. They are public support APIs prepared for third-party TestEngine and extension authors, so they can be used safely.

Controlling Test Execution Conditions

Implement ExecutionCondition and return a ConditionEvaluationResult from evaluateExecutionCondition(ExtensionContext). The returned value determines whether the target test is enabled or disabled. This callback is invoked whenever a relevant test is evaluated.

Creating Test Instances

Implement TestInstanceFactory to customize how test instances are created. createTestInstance() is called before each test method is executed and can use reflection support to create the object.

Post-Processing Test Instances

Implement TestInstancePostProcessor to initialize test instances after creation. This is useful for dependency injection or invoking initialization methods.

Parameter Resolution

Implement ParameterResolver to provide arguments to test methods, lifecycle methods, constructors, or dynamic tests. supportsParameter() checks whether a parameter is supported, and resolveParameter() returns the actual value. To read Java parameter names, compile with the -parameters option.

Lifecycle Callbacks

Lifecycle callback interfaces let an extension run logic around JUnit lifecycle points such as before all tests, before each test, before test execution, after test execution, after each test, and after all tests.

Processing Test Results

Implement TestWatcher to react to test outcomes such as success, failure, abort, or disabled state. Its methods are default methods with empty bodies and run after AfterEachCallback.

Handling Exceptions from Tests

Implement TestExecutionExceptionHandler to handle exceptions thrown from test methods. Assertion errors are also targets, so handle them carefully.

Handling Exceptions from Lifecycle Methods

Use LifecycleMethodExecutionExceptionHandler to handle exceptions thrown from lifecycle methods such as @BeforeAll, @BeforeEach, @AfterEach, and @AfterAll. This is separate from TestExecutionExceptionHandler, which handles exceptions from test execution.

Running the Same Test in Different Contexts

Use TestTemplateInvocationContextProvider with @TestTemplate to execute the same test in different invocation contexts. supportsTestTemplate() decides support, and provideTestTemplateInvocationContexts() provides the contexts. Each context can define a display name and additional extensions.

Programmatic Extension Registration

@RegisterExtension registers an extension through a field on the test class. This lets you configure extension instances dynamically. Static fields can register class-level extensions, while instance fields cannot use some class-level callbacks such as BeforeAllCallback.

Automatic Registration with ServiceLoader

Extensions can be registered automatically through Java’s ServiceLoader. Create /META-INF/services/org.junit.jupiter.api.extension.Extension and list extension implementation classes. Enable auto-detection with:

junit.jupiter.extensions.autodetection.enabled=true

Avoid sharing extension state through instance fields when tests may run in parallel, because the same extension instance can be reused across tests. Instead, use ExtensionContext.Store.

Store is obtained from an ExtensionContext with a Namespace. Separate namespaces prevent key collisions between extensions. Use Namespace.GLOBAL only when data should be shared across all extensions.

Store Lifecycle and Lookup

A Store has the same lifecycle as the ExtensionContext from which it is obtained. Method-level extension contexts have parent class-level contexts, and data stored in a parent context can be found from child contexts.

Cleanup at Lifecycle End

Objects stored in Store can implement ExtensionContext.Store.CloseableResource. Their close() method is called automatically when the corresponding store lifecycle ends, making it useful for cleanup logic.

JUnit 5 Meta Annotation

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

Meta Annotations

JUnit Jupiter supports a meta-annotation mechanism. This means you can define your own annotation by combining arbitrary annotations.

If the same annotation combination is used in several places, wrapping it into one custom annotation improves reuse.

It can also decouple tests from a specific implementation because tests can use a custom annotation instead of specifying an extension class directly with @ExtendWith.

A common pattern is to implement a ParameterResolver, then create a custom annotation that adds @ExtendWith(MyParameterResolver.class). Tests can then use that custom annotation and receive resolved method parameters.

JUnit 5 Assertions

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

Assertion

JUnit 5 provides an assertion class named Assertions. Assertions verify values or behavior that a test wants to check.

Value Assertions

JUnit provides basic assertion methods.

`assertEquals`

assertEquals(expected, actual, {message}) checks whether the actual value equals the expected value.

`assertNull(actual)`

assertNull(actual, {message}) checks whether a value is null.

`assertNotNull(actual)`

assertNotNull(actual, {message}) checks whether a value is not null.

`assertTrue(boolean)`

assertTrue(actual, {message}) checks whether the condition is true.

`assertFalse(boolean)`

assertFalse(actual, {message}) checks whether the condition is false.

Convenient Assertions

Besides value assertions, JUnit provides useful assertion helpers.

`assertAll(executable...)`

assertAll runs multiple assertions together. If ordinary assertions are written one after another, execution stops when an earlier assertion fails, so later failures are not visible. With assertAll, the results of all assertions can be checked.

`assertThrows(expectedType, executable)`

assertThrows checks whether an exception is thrown. The returned exception can also be used to check the exception message.

`assertTimeout(duration, executable)`

assertTimeout checks whether execution completes within a specified time. The test completes after the lambda expression passed as the second argument ends.

`assertTimeoutPreemptively(duration, executable)`

assertTimeoutPreemptively also checks whether execution completes within a specified time. The difference from assertTimeout is that assertTimeout waits until execution finishes, whereas assertTimeoutPreemptively aborts the test as soon as the specified time passes.

Caution

Use this carefully because the lambda passed as the second argument is executed in a separate `Thread`. For example, if database transaction code is inside it, rollback may not work as expected.

Other Assertion Libraries

JUnit 5 can use other assertion libraries. By adding dependencies such as AssertJ or Hamcrest, they can be used much like in JUnit 4.

AssertJ

AssertJ supports method chaining, so it helps write cleaner and more readable test code. Add org.assertj:assertj-core as a test dependency before using it.

How to Test private Methods with JUnit

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

Overview

JUnit is commonly used for Java unit tests. Test code is usually written for public methods, but tests for private and protected methods are often neglected.

Because white-box testing can be considered a programmer’s responsibility, every part of the code should be testable. This page explains how to test every method.

Test Source Code

First, create a simple class to test. The sample has a public addition method, a protected subtraction method, and a private multiplication method.

Testing public Methods

A normal test case can directly create an instance and call the public method. This is the ordinary JUnit testing style.

Testing protected and private Methods

Because protected and private methods cannot be called directly from an instance in the same way, use Java reflection.

Sample sample = new Sample();
Method method = Sample.class.getDeclaredMethod("{methodName}", {arg1}, {arg2}...);
method.setAccessible(true);
int actual = ({return type}) method.invoke(<instance>, {arg1}, {arg2}...);

Use the class variable available on every class and call getDeclaredMethod() to obtain the method under test. Set setAccessible(true) on the returned method so it can be accessed externally, then execute it with method.invoke().

Conclusion

Using reflection makes it possible to test methods that cannot be called directly. Bugs are a programmer’s enemy, so remove as many possible bugs as practical.

What Is Mockito?

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

Mockito

Mockito is a framework that makes it easy to create, manage, and verify mock objects in Java tests.

A mock is a fake object used for testing. Mockito can create a mock of a specified class, stub any method to return a specified value, and verify whether a mock method was called as expected. One of its strengths is that mock behavior can be defined in a type-safe style.

HelloWorld

Add Mockito as a test dependency, for example org.mockito:mockito-core. Then create a mock object with mock() and define behavior with when(...).thenReturn(...).

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

Here, a mock java.util.List is created, and get(0) is defined to return "Hello Mockito!".

Default Mock Behavior

Methods on a mock return default values if they are not stubbed. Primitive values return zero-like values, collections can return empty collections, and object references generally return null.

Creating Stubs with `when`

Use the following form to specify the value returned by a mock method.

when(<method call to stub>).thenReturn(<method return value>)

Once a method is stubbed, it returns the same value every time unless another stub overrides it.

Returning Different Values on Each Call

Use the varargs form thenReturn(T...) to return a different value for each call. If the method is called more times than the number of specified values, Mockito keeps returning the last value.

Throwing Exceptions

Use thenThrow(Throwable...) to make a stub throw exceptions. The varargs form can throw different exceptions on consecutive calls, and after the specified exceptions are exhausted, the last exception keeps being thrown.

Combining Return Values and Exceptions

Mockito can also combine return values and thrown exceptions for consecutive calls.

Matching Arbitrary Arguments

Use methods from ArgumentMatchers, such as anyInt(), anyList(), or any(), to define stubs for arbitrary arguments.

When a method has multiple arguments, if one argument uses a matcher, all other arguments must also be provided by matchers. Use eq() when you want to match a specific value while using matchers for other arguments.

Custom Argument Matching

Custom matchers can be used when built-in matchers are not enough.

Running Arbitrary Logic in a Stub

Use thenAnswer() when a stub needs to execute arbitrary logic. Mockito also provides typed answer helpers such as Answer1 through Answer6. Avoid overusing complex stubs because they can make tests harder to understand and maintain. The official documentation recommends using thenReturn() and thenThrow() whenever possible.

Stubbing `void` Methods

For void methods, use stubbing methods that start with doThrow() when you want the method to throw an exception.

Verifying Method Calls

Use verify() to check whether a method was called. Verification includes arguments.

Mockito can verify:

Whether a method was called with matching arguments.
How many times a method was called.
Whether it was called at least or at most a given number of times.
Whether it was never called.
The order of method calls with InOrder.
The order of calls across multiple mocks.
Actual arguments passed to a method with ArgumentCaptor.

Spy

A spy is based on a real object. If a spy method is not stubbed, the real method is executed. The spy is created from a copy of the original object, so changes to the spy and original object are not always shared.

When stubbing a spy, when(spy.method()) can call the real method during stubbing. Use doReturn().when(spy).method() to avoid calling the real method. Use doThrow() if you want to stub a spy method to throw an exception without executing the real method.

Mockito can also create spies for abstract classes with spy(Class), provided that the target class has a default constructor.

Delegating to Another Object

AdditionalAnswers.delegatesTo() can create a mock or spy-like object that delegates calls to another object. The delegate does not need to inherit from the mocked type.

Serializable Mocks

Mockito can create serializable mocks by using withSettings().serializable().

One-Liner Mock and Stub

Mockito can create a mock and define its stub in a compact one-liner, but use this style carefully so tests remain readable.

Defining Mocks with Annotations

Mockito supports field annotations such as @Mock, @Spy, and @Captor. Initialize them with Mockito’s annotation support. For JUnit 5, add mockito-junit-jupiter and use MockitoExtension; mocks can also be received as method parameters.

Inline Mock Maker

The inline mock maker enables features that ordinary Mockito cannot provide, such as mocking final classes and stubbing static methods. Add the org.mockito:mockito-inline dependency.

With inline mock maker, you can:

Mock and stub final classes and methods.
Stub static methods with Mockito.mockStatic(Class).
Return mocks from constructors with mockConstruction().

Constructor mocking is valid only until the returned MockedConstruction is closed. Stubbing and verification use ordinary Mockito APIs such as when() and verify().

Classes That Must Not Be Mocked

Mockito provides @DoNotMock to mark classes that should not be mocked. If such a class is mocked, Mockito fails and asks you to create a real instance instead.

References

WebClient Testing - Testing External API Calls with MockWebServer

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

Overview

Most modern services are expected to call REST APIs. Spring provides several options for building REST clients and recommends WebClient.

This page explains how to unit test a service that calls an API by using WebClient.

What Is MockWebServer?

MockWebServer from Square is a small, simple web server that receives HTTP requests and returns responses.

When testing methods that call HTTP through clients such as WebClient or RestTemplate, you can point the client to MockWebServer and write tests more easily. The Spring team also recommends using MockWebServer for this kind of test.

Creating a Simple WebClient Project

Before using MockWebServer, create a simple project that uses WebClient as the test target. The sample project can be generated from Spring Initializr with Java 11, Gradle, Spring Boot 2.7.6, and the webflux dependency.

Create a DTO object to receive data, then create service code that uses WebClient to call /users/{id} and returns Mono<User>.

Applying MockWebServer

Adding the Dependency

Add the MockWebServer test dependency.

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

Adding MockWebServer to Test Code

In test code, create a MockWebServer object in @BeforeAll, start it, and shut it down in @AfterAll.

Passing WebClient to the Service

Create a WebClient with a base URL that uses the MockWebServer port and pass it to the service.

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

With this setup, the test calls MockWebServer instead of a real external URL.

Creating an Arbitrary Response

Create a MockResponse, set the body and headers, and put it into enqueue. MockWebServer returns responses in the order they were enqueued.

Checking the Request

Besides checking the response value, you can also inspect the request with takeRequest().

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

References

The example code above is available on GitHub.

devkuma – Java

JUnit

How to Apply JUnit 5

Build Environment

Writing Test Code

How to Apply It in Spring Boot

JUnit 5 Overview

What Is JUnit?

Unit Tests and Functional Tests

Unit Tests

Functional Tests

JUnit 5 Support

JUnit 5 Structure

Related Links

Design Pattern | Abstract Factory Methods

What Is the Abstract Factory Pattern?

Abstract Factory Pattern Example Program

1. Factory Class

2. Item Class

3. Link Class

4. Tray Class

5. Page Class

6. ListFactory Class

7. ListLink Class

8. ListTray Class

9. ListPage Class

10. Main Class

11. Execution Result

Advantages of the Abstract Factory Pattern

How to Run JUnit 5 Tests - ConsoleLauncher, Gradle

Using ConsoleLauncher

Running Tests

Test Output

Command Help

Running Tests with Gradle

Gradle Configuration

Running Test Code

Design Pattern | Builder Pattern

What Is the Builder Pattern?

Builder Pattern Example Program

1. Builder Class

2. Guide Class

3. TextBuilder Class

4. HTMLBuilder Class

5. Main Class

6. Execution Result

7. Advantages of the Builder Pattern

Design Pattern | Prototype Pattern

What Is the Prototype Pattern?

Prototype Pattern Example Program

1. Product Interface

2. Manager Class

3. UnderlinePen Class

4. MessageBox Class

5. Main Class

6. Execution Result

Advantages of the Prototype Pattern

Design Pattern | Singleton Pattern

What Is the Singleton Pattern?

Singleton Pattern Example Program

1. Singleton Class

2. Main Class

3. Execution Result

Advantages of the Singleton Pattern

Singleton Pattern Using synchronized

Example Program for Singleton Pattern Using synchronized

Example Program for a Singleton Pattern with Improved synchronized Performance

JUnit 5 Basic Tests - @Test, @DisplayName, @Disabled

Failed and Successful Tests

Displaying Test Names with @DisplayName

Disabling Tests

JUnit 5 Lifecycle - @BeforeAll, @BeforeEach, @AfterAll, @AfterEach

@BeforeAll

@BeforeEach

@AfterEach

@AfterAll

Execution Order

Reference

JUnit 5 Test Execution Order - Method Name, @Order, Random

Test Execution Order

Displaying Test Names with `@DisplayName`

`@BeforeAll`

`@BeforeEach`

`@AfterEach`

`@AfterAll`

Order with `@Order`

`@ValueSource`

`@EnumSource`

`@MethodSource`

`assertEquals`

`assertNull(actual)`

`assertNotNull(actual)`

`assertTrue(boolean)`

`assertFalse(boolean)`