Java >> Java チュートリアル >  >> Tag >> assert

JUnit 5 チュートリアル:Hamcrest を使用したアサーションの記述

このブログ投稿では、Hamcrest を使用してアサーションを作成する方法について説明しています。このブログ投稿を終えたら、次のことを行います。

  • Maven と Gradle で必要な依存関係を取得できる
  • Hamcrest を使用して基本的なアサーションを作成する方法を理解する
  • 複数の Hamcrest マッチャーを組み合わせる方法を理解する
  • アサーションが失敗したときに表示されるエラー メッセージをカスタマイズできます。

始めましょう。

必要な依存関係を取得する

Hamcrest でアサーションを書く前に、hamcrest-library を確認する必要があります。 依存関係 (バージョン 2.2) がクラスパスから見つかりました。

Maven を使用している場合は、hamcrest-library を追加する必要があります test への依存 範囲。これを行うには、次のスニペットを depencies に追加します。 pom.xml のセクション ファイル:

<dependency>
	<groupId>org.hamcrest</groupId>
	<artifactId>hamcrest-library</artifactId>
	<version>2.2</version>
	<scope>test</scope>
</dependency>

Gradle を使用している場合は、hamcrest-library を追加する必要があります testImplementation への依存 依存関係の構成。これを行うには、build.gradle に次のスニペットを追加します。 ファイル:

dependencies {
    testImplementation(
            'org.hamcrest:hamcrest-library:2.2'
    )
}

hamcrest-library であることを確認した後、 依存関係がクラスパスから見つかった場合、Hamcrest でアサーションを記述できます。どうすればできるか見てみましょう。

Hamcrest でアサーションを書く

JUnit 4 で Hamcrest を使用したことがある場合は、おそらく assertThat() を使用する必要があったことを覚えているでしょう。 org.junit.Assert のメソッド クラス。ただし、JUnit 5 API には、Hamcrest マッチャーをメソッド パラメーターとして受け取るメソッドがありません。 JUnit 5 ユーザー ガイドでは、この設計上の決定について次のように説明しています。

ただし、JUnit Jupiter の org.junit.jupiter.api.Assertions クラスは assertThat() を提供しません JUnit 4 の org.junit.Assert にあるようなメソッド Hamcrest Matcher を受け入れるクラス .代わりに、開発者は、サードパーティのアサーション ライブラリが提供するマッチャーの組み込みサポートを使用することをお勧めします。

つまり、Hamcrest マッチャーを使用する場合は、assertThat() を使用する必要があります。 org.hamcrest.MatcherAssert のメソッド クラス。このメソッドは、次に説明する 2 つまたは 3 つのメソッド パラメータを受け取ります:

<オール>
  • アサーションが失敗したときに表示されるオプションのエラー メッセージ。
  • 実際の値またはオブジェクト
  • A Matcher 期待値を指定するオブジェクト。新しい Matcher を作成できます static を使用したオブジェクト org.hamcrest.Matchers によって提供されるファクトリ メソッド クラス。
  • 次に、Hamcrest を使用してアサーションを作成する方法を示すいくつかの例を見ていきます。 boolean のアサーションを書く方法を見つけることから始めましょう

    ブール値のアサート

    boolean であることを確認したい場合 値は true です is() を呼び出して Hamcrest マッチャーを作成する必要があります。 Matchers のメソッド クラス。つまり、次のアサーションを使用する必要があります:

    import org.junit.jupiter.api.DisplayName;
    import org.junit.jupiter.api.Nested;
    import org.junit.jupiter.api.Test;
    
    import static org.hamcrest.Matchers.is;
    import static org.hamcrest.MatcherAssert.assertThat;
    
    @DisplayName("Write assertions for booleans")
    class BooleanAssertionTest {
    
        @Nested
        @DisplayName("When boolean is true")
        class WhenBooleanIsTrue {
    
            @Test
            @DisplayName("Should be true")
            void shouldBeTrue() {
                assertThat(true, is(true));
            }
        }
    }
    

    boolean であることを確認したい場合 値は false です is() を呼び出して Hamcrest マッチャを作成する必要があります。 Matchers のメソッド クラス。つまり、次のアサーションを使用する必要があります:

    import org.junit.jupiter.api.DisplayName;
    import org.junit.jupiter.api.Nested;
    import org.junit.jupiter.api.Test;
    
    import static org.hamcrest.Matchers.is;
    import static org.hamcrest.MatcherAssert.assertThat;
    
    @DisplayName("Write assertions for booleans")
    class BooleanAssertionTest {
    
        @Nested
        @DisplayName("When boolean is false")
        class WhenBooleanIsFalse {
    
            @Test
            @DisplayName("Should be false")
            void shouldBeFalse() {
                assertThat(false, is(false));
            }
        }
    }
    

    オブジェクトが null であることを確認する方法を見てみましょう。 または null ではない .

    オブジェクトが Null であるか、または Null ではないことをアサートする

    オブジェクトが null であることを確認したい場合 nullValue() を呼び出して Hamcrest マッチャーを作成する必要があります。 Matchers のメソッド クラス。つまり、次のアサーションを使用する必要があります:

    import org.junit.jupiter.api.DisplayName;
    import org.junit.jupiter.api.Nested;
    import org.junit.jupiter.api.Test;
    
    import static org.hamcrest.MatcherAssert.assertThat;
    import static org.hamcrest.Matchers.nullValue;
    
    @DisplayName("Writing assertions for objects")
    class ObjectAssertionTest {
    
        @Nested
        @DisplayName("When object is null")
        class WhenObjectIsNull {
    
            @Test
            @DisplayName("Should be null")
            void shouldBeNull() {
                assertThat(null, nullValue());
            }
        }
    }
    

    オブジェクトが null でないことを確認したい場合 notNullValue() を呼び出して Hamcrest マッチャーを作成する必要があります。 Matchers のメソッド クラス。つまり、次のアサーションを使用する必要があります:

    import org.junit.jupiter.api.DisplayName;
    import org.junit.jupiter.api.Nested;
    import org.junit.jupiter.api.Test;
    
    import static org.hamcrest.MatcherAssert.assertThat;
    import static org.hamcrest.Matchers.notNullValue;
    
    @DisplayName("Writing assertions for objects")
    class ObjectAssertionTest {
    
        @Nested
        @DisplayName("When object is not null")
        class WhenObjectIsNotNotNull {
    
            @Test
            @DisplayName("Should not be null")
            void shouldNotBeNull() {
                assertThat(new Object(), notNullValue());
            }
        }
    }
    

    次に、2 つのオブジェクト (または値) が等しいか等しくないかを確認する方法を見つけます。

    2 つのオブジェクトまたは値が等しいと主張する

    期待値 (またはオブジェクト) が実際の値 (またはオブジェクト) と等しいことを確認したい場合は、equalTo() を呼び出して Hamcrest マッチャーを作成する必要があります。 Matchers のメソッド クラス。たとえば、2 つの Integer を比較したい場合 オブジェクト、このアサーションを使用する必要があります:

    import org.junit.jupiter.api.DisplayName;
    import org.junit.jupiter.api.Nested;
    import org.junit.jupiter.api.Test;
    
    import static org.hamcrest.MatcherAssert.assertThat;
    import static org.hamcrest.Matchers.equalTo;
    
    @DisplayName("Writing assertions for objects")
    class ObjectAssertionTest {
    
        @Nested
        @DisplayName("When two objects are equal")
        class WhenTwoObjectsAreEqual {
    
            @Nested
            @DisplayName("When objects are integers")
            class WhenObjectsAreIntegers {
    
                private final Integer ACTUAL = 9;
                private final Integer EXPECTED = 9;
    
                @Test
                @DisplayName("Should be equal")
                void shouldBeEqual() {
                    assertThat(ACTUAL, equalTo(EXPECTED));
                }
            }
        }
    }
    

    期待値 (またはオブジェクト) が実際の値 (またはオブジェクト) と等しくないことを確認したい場合は、not() を呼び出して Hamcrest マッチャを作成する必要があります。 Matchers のメソッド クラス。たとえば、2 つの Integer を比較したい場合 オブジェクト、このアサーションを使用する必要があります:

    import org.junit.jupiter.api.DisplayName;
    import org.junit.jupiter.api.Nested;
    import org.junit.jupiter.api.Test;
    
    import static org.hamcrest.MatcherAssert.assertThat;
    import static org.hamcrest.Matchers.not;
    
    @DisplayName("Writing assertions for objects")
    class ObjectAssertionTest {
    
        @Nested
        @DisplayName("When two objects aren't equal")
        class WhenTwoObjectsAreNotEqual {
    
            @Nested
            @DisplayName("When objects are integers")
            class WhenObjectsAreIntegers {
    
                private final Integer ACTUAL = 9;
                private final Integer EXPECTED = 4;
    
                @Test
                @DisplayName("Should not be equal")
                void shouldNotBeEqual() {
                    assertThat(ACTUAL, not(EXPECTED));
                }
            }
        }
    }
    

    オブジェクト参照のアサーションを記述する方法を見てみましょう。

    オブジェクト参照のアサート

    2 つのオブジェクトが同じオブジェクトを参照していることを確認するには、sameInstance() を呼び出して Hamcrest マッチャーを作成する必要があります。 Matchers のメソッド クラス。つまり、次のアサーションを使用する必要があります:

    import org.junit.jupiter.api.DisplayName;
    import org.junit.jupiter.api.Nested;
    import org.junit.jupiter.api.Test;
    
    import static org.hamcrest.MatcherAssert.assertThat;
    import static org.hamcrest.Matchers.sameInstance;
    
    @DisplayName("Writing assertions for objects")
    class ObjectAssertionTest {
    
        @Nested
        @DisplayName("When two objects refer to the same object")
        class WhenTwoObjectsReferToSameObject {
    
            private final Object ACTUAL = new Object();
            private final Object EXPECTED = ACTUAL;
    
            @Test
            @DisplayName("Should refer to the same object")
            void shouldReferToSameObject() {
                assertThat(ACTUAL, sameInstance(EXPECTED));
            }
        }
    }
    

    2 つのオブジェクトが同じオブジェクトを参照しないようにしたい場合は、sameInstance() で指定された予想を逆にする必要があります。 not() を使用した方法 Matchers のメソッド クラス。つまり、次のアサーションを使用する必要があります:

    import org.junit.jupiter.api.DisplayName;
    import org.junit.jupiter.api.Nested;
    import org.junit.jupiter.api.Test;
    
    import static org.hamcrest.MatcherAssert.assertThat;
    import static org.hamcrest.Matchers.not;
    import static org.hamcrest.Matchers.sameInstance;
    
    @DisplayName("Writing assertions for objects")
    class ObjectAssertionTest {
    
        @Nested
        @DisplayName("When two objects don't refer to the same object")
        class WhenTwoObjectsDoNotReferToSameObject {
    
            private final Object ACTUAL = new Object();
            private final Object EXPECTED = new Object();
    
            @Test
            @DisplayName("Should not refer to the same object")
            void shouldNotReferToSameObject() {
               assertThat(ACTUAL, not(sameInstance(EXPECTED)));
            }
        }
    }
    

    次に、2 つの配列が等しいことを確認する方法を見つけます。

    2 つの配列が等しいと主張する

    2 つの配列が等しいことを確認したい場合は、equalTo() を呼び出して Hamcrest マッチャを作成する必要があります。 Matchers のメソッド クラス。たとえば、2 つの int を確認したい場合 配列が等しい場合、このアサーションを使用する必要があります:

    import org.junit.jupiter.api.DisplayName;
    import org.junit.jupiter.api.Nested;
    import org.junit.jupiter.api.Test;
    
    import static org.hamcrest.Matchers.equalTo;
    import static org.hamcrest.MatcherAssert.assertThat;
    
    @DisplayName("Write assertions for arrays")
    class ArrayAssertionTest {
    
        @Nested
        @DisplayName("When arrays contain integers")
        class WhenArraysContainIntegers {
    
            final int[] ACTUAL = new int[]{2, 5, 7};
            final int[] EXPECTED = new int[]{2, 5, 7};
    
            @Test
            @DisplayName("Should contain the same integers")
            void shouldContainSameIntegers() {
                assertThat(ACTUAL, equalTo(EXPECTED));
            }
        }
    }
    

    次に進み、リストのアサーションを記述する方法を見てみましょう。

    アサート リスト

    リストのサイズが正しいことを検証するアサーションを書きたい場合は、hasSize() を呼び出して Hamcrest マッチャーを作成する必要があります。 Matchers のメソッド クラス。たとえば、リストのサイズが 2 であることを確認する場合、次のアサーションを使用する必要があります:

    import org.junit.jupiter.api.BeforeEach;
    import org.junit.jupiter.api.DisplayName;
    import org.junit.jupiter.api.Nested;
    import org.junit.jupiter.api.Test;
    
    import java.util.Arrays;
    import java.util.List;
    
    import static org.hamcrest.MatcherAssert.assertThat;
    import static org.hamcrest.Matchers.hasSize;
    
    @DisplayName("Writing assertions for lists")
    class ListAssertionTest {
    
        @Nested
        @DisplayName("When we write assertions for elements")
        class WhenWeWriteAssertionsForElements {
            
            private Object first;
            private Object second;
    
            private List<Object> list;
    
            @BeforeEach
            void createAndInitializeList() {
                first = new Object();
                second = new Object();
    
                list = Arrays.asList(first, second);
            }
    
            @Test
            @DisplayName("Should contain two elements")
            void shouldContainTwoElements() {
                assertThat(list, hasSize(2));
            }
        }
    }
    

    リストに指定された順序で期待される要素のみが含まれていることを確認したい場合は、contains() を呼び出して Hamcrest マッチャーを作成する必要があります。 Matchers のメソッド クラス。たとえば、リストに正しい要素が指定された順序で含まれていることを確認する場合は、次のアサーションを使用する必要があります:

    import org.junit.jupiter.api.BeforeEach;
    import org.junit.jupiter.api.DisplayName;
    import org.junit.jupiter.api.Nested;
    import org.junit.jupiter.api.Test;
    
    import java.util.Arrays;
    import java.util.List;
    
    import static org.hamcrest.MatcherAssert.assertThat;
    import static org.hamcrest.Matchers.contains;
    
    @DisplayName("Writing assertions for lists")
    class ListAssertionTest {
    
        @Nested
        @DisplayName("When we write assertions for elements")
        class WhenWeWriteAssertionsForElements {
    
            private Object first;
            private Object second;
    
            private List<Object> list;
    
            @BeforeEach
            void createAndInitializeList() {
                first = new Object();
                second = new Object();
    
                list = Arrays.asList(first, second);
            }
    
            @Test
            @DisplayName("Should contain the correct elements in the given order")
            void shouldContainCorrectElementsInGivenOrder() {
                assertThat(list, contains(first, second));
            }
        }
    }
    

    リストに期待される要素のみが任意の順序で含まれていることを確認したい場合は、containsInAnyOrder() を呼び出して Hamcrest マッチャーを作成する必要があります。 Matchers のメソッド クラス。たとえば、リストに正しい要素が任意の順序で含まれていることを確認したい場合は、次のアサーションを使用する必要があります:

    import org.junit.jupiter.api.BeforeEach;
    import org.junit.jupiter.api.DisplayName;
    import org.junit.jupiter.api.Nested;
    import org.junit.jupiter.api.Test;
    
    import java.util.Arrays;
    import java.util.List;
    
    import static org.hamcrest.MatcherAssert.assertThat;
    import static org.hamcrest.Matchers.containsInAnyOrder;
    
    @DisplayName("Writing assertions for lists")
    class ListAssertionTest {
    
        @Nested
        @DisplayName("When we write assertions for elements")
        class WhenWeWriteAssertionsForElements {
    
            private Object first;
            private Object second;
    
            private List<Object> list;
    
            @BeforeEach
            void createAndInitializeList() {
                first = new Object();
                second = new Object();
    
                list = Arrays.asList(first, second);
            }
    
            @Test
            @DisplayName("Should contain the correct elements in any order")
            void shouldContainCorrectElementsInAnyOrder() {
                assertThat(list, containsInAnyOrder(second, first));
            }
        }
    }
    

    リストに特定の要素が含まれていることを確認したい場合は、hasItem() を呼び出して Hamcrest マッチャーを作成する必要があります。 Matchers のメソッド クラス。たとえば、リストに Object が含まれていることを確認したい場合 first というフィールドに保存されます 、このアサーションを使用する必要があります:

    import org.junit.jupiter.api.BeforeEach;
    import org.junit.jupiter.api.DisplayName;
    import org.junit.jupiter.api.Nested;
    import org.junit.jupiter.api.Test;
    
    import java.util.Arrays;
    import java.util.List;
    
    import static org.hamcrest.MatcherAssert.assertThat;
    import static org.hamcrest.Matchers.hasItem;
    
    @DisplayName("Writing assertions for lists")
    class ListAssertionTest {
    
        @Nested
        @DisplayName("When we write assertions for elements")
        class WhenWeWriteAssertionsForElements {
    
            private Object first;
            private Object second;
    
            private List<Object> list;
    
            @BeforeEach
            void createAndInitializeList() {
                first = new Object();
                second = new Object();
    
                list = Arrays.asList(first, second);
            }
    
            @Test
            @DisplayName("Should contain a correct element")
            void shouldContainCorrectElement() {
                assertThat(list, hasItem(first));
            }
        }
    }
    

    リストに要素が含まれていないことを確認したい場合は、 hasItem() で指定された期待を逆にする必要があります not() を使用した方法 Matchers のメソッド クラス。つまり、次のアサーションを使用する必要があります:

    import org.junit.jupiter.api.BeforeEach;
    import org.junit.jupiter.api.DisplayName;
    import org.junit.jupiter.api.Nested;
    import org.junit.jupiter.api.Test;
    
    import java.util.Arrays;
    import java.util.List;
    
    import static org.hamcrest.MatcherAssert.assertThat;
    import static org.hamcrest.Matchers.hasItem;
    import static org.hamcrest.Matchers.not;
    
    @DisplayName("Writing assertions for lists")
    class ListAssertionTest {
    
        @Nested
        @DisplayName("When we write assertions for elements")
        class WhenWeWriteAssertionsForElements {
    
            private Object first;
            private Object second;
    
            private List<Object> list;
    
            @BeforeEach
            void createAndInitializeList() {
                first = new Object();
                second = new Object();
    
                list = Arrays.asList(first, second);
            }
    
            @Test
            @DisplayName("Should not contain an incorrect element")
            void shouldNotContainIncorrectElement() {
                assertThat(list, not(hasItem(new Object())));
            }
        }
    }
    

    2 つのリストが完全に等しいことを確認したい場合は、equalTo() を呼び出して Hamcrest マッチャを作成する必要があります。 Matchers のメソッド クラス。たとえば、2 つの Integer を確認したい場合 リストは非常に等しいので、次のアサーションを使用する必要があります:

    import org.junit.jupiter.api.DisplayName;
    import org.junit.jupiter.api.Nested;
    import org.junit.jupiter.api.Test;
    
    import java.util.Arrays;
    import java.util.List;
    
    import static org.hamcrest.MatcherAssert.assertThat;
    import static org.hamcrest.Matchers.equalTo;
    
    @DisplayName("Writing assertions for lists")
    class ListAssertionTest {
    
        @Nested
        @DisplayName("When we compare two lists")
        class WhenWeCompareTwoLists {
    
            private final List<Integer> ACTUAL = Arrays.asList(1, 2, 3);
            private final List<Integer> EXPECTED = Arrays.asList(1, 2, 3);
    
            @Test
            @DisplayName("Should contain the same elements")
            void shouldContainSameElements() {
                assertThat(ACTUAL, equalTo(EXPECTED));
            }
        }
    }
    

    次に、マップのアサーションを記述する方法を確認します。

    マップのアサート

    マップに指定されたキーが含まれていることを確認したい場合は、hasKey() を呼び出して Hamcrest マッチャーを作成する必要があります。 Matchers のメソッド クラス。つまり、次のアサーションを使用する必要があります:

    import org.junit.jupiter.api.BeforeEach;
    import org.junit.jupiter.api.DisplayName;
    import org.junit.jupiter.api.Nested;
    import org.junit.jupiter.api.Test;
    
    import java.util.HashMap;
    import java.util.Map;
    
    import static org.hamcrest.MatcherAssert.assertThat;
    import static org.hamcrest.Matchers.hasKey;
    
    @DisplayName("Writing assertions for maps")
    class MapAssertionTest {
        
        private static final String KEY = "key";
        private static final String VALUE = "value";
    
        private Map<String, String> map;
    
        @BeforeEach
        void createAndInitializeMap() {
            map = new HashMap<>();
            map.put(KEY, VALUE);
        }
    
        @Nested
        @DisplayName("When we check if the map contains the given key")
        class WhenWeCheckIfMapContainsGivenKey {
    
            @Test
            @DisplayName("Should contain the correct key")
            void shouldContainCorrectKey() {
                assertThat(map, hasKey(KEY));
            }
        }
    }
    

    マップに指定されたキーが含まれていないことを確認したい場合は、 hasKey() で指定された予想を逆にする必要があります not() を使用した方法 Matchers のメソッド クラス。つまり、次のアサーションを使用する必要があります:

    import org.junit.jupiter.api.BeforeEach;
    import org.junit.jupiter.api.DisplayName;
    import org.junit.jupiter.api.Nested;
    import org.junit.jupiter.api.Test;
    
    import java.util.HashMap;
    import java.util.Map;
    
    import static org.hamcrest.MatcherAssert.assertThat;
    import static org.hamcrest.Matchers.hasKey;
    import static org.hamcrest.Matchers.not;
    
    @DisplayName("Writing assertions for maps")
    class MapAssertionTest {
    
        private static final String INCORRECT_KEY = "incorrectKey";
        private static final String KEY = "key";
        private static final String VALUE = "value";
    
        private Map<String, String> map;
    
        @BeforeEach
        void createAndInitializeMap() {
            map = new HashMap<>();
            map.put(KEY, VALUE);
        }
    
        @Nested
        @DisplayName("When we check if the map contains the given key")
        class WhenWeCheckIfMapContainsGivenKey {
    
            @Test
            @DisplayName("Should not contain the incorrect key")
            void shouldNotContainIncorrectKey() {
                assertThat(map, not(hasKey(INCORRECT_KEY)));
            }
        }
    }
    

    マップに正しい値が含まれていることを確認するには、hasEntry() を呼び出して Hamcrest マッチャーを作成する必要があります。 Matchers のメソッド クラス。つまり、次のアサーションを使用する必要があります:

    import org.junit.jupiter.api.BeforeEach;
    import org.junit.jupiter.api.DisplayName;
    import org.junit.jupiter.api.Nested;
    import org.junit.jupiter.api.Test;
    
    import java.util.HashMap;
    import java.util.Map;
    
    import static org.hamcrest.MatcherAssert.assertThat;
    import static org.hamcrest.Matchers.hasEntry;
    
    @DisplayName("Writing assertions for maps")
    class MapAssertionTest {
        
        private static final String KEY = "key";
        private static final String VALUE = "value";
    
        private Map<String, String> map;
    
        @BeforeEach
        void createAndInitializeMap() {
            map = new HashMap<>();
            map.put(KEY, VALUE);
        }
    
        @Nested
        @DisplayName("When we check if the map contains the correct value")
        class WhenWeCheckIfMapContainsCorrectValue {
    
            @Test
            @DisplayName("Should contain the correct value")
            void shouldContainCorrectValue() {
                assertThat(map, hasEntry(KEY, VALUE));
            }
        }
    }
    

    次に進み、複数の Hamcrest マッチャーを組み合わせる方法を見てみましょう。

    Hamcrest Matcher の結合

    Hamcrest で基本的なアサーションを記述できるようになりました。ただし、複数の Hamcrest マッチャを組み合わせる必要がある場合もあります。実際、not() を呼び出すことで Hamcrest マッチャーの期待を逆転させたときに、すでにこれを行っています。 Matchers のメソッド クラス。

    次に、Person のアサーションを作成するときに Hamcrest マッチャーを組み合わせる方法を示す 2 つの例を見ていきます。 物体。 Person のソースコード クラスは次のようになります:

    public class Person {
     
        private String firstName;
        private String lastName;
     
        public Person() {}
     
        public String getFirstName() {
            return firstName;
        }
     
        public String getLastName() {
            return lastName;
        }
     
        public void setFirstName(String firstName) {
            this.firstName = firstName;
        }
     
        public void setLastName(String lastName) {
            this.lastName = lastName;
        }
    }
    

    お分かりのように、人が正しい名前を持っていることを確認したい場合は、アサートされた Person を確認する必要があります。 オブジェクトの姓名が正しいこと。このアサーションを記述するとき、assertThat() に渡される Hamcrest マッチャーを作成する必要があります。 これらの Hamcrest Matcher を使用したメソッド:

    • allOf() Matchers のメソッド クラスは、アサートされたオブジェクトが all と一致することを期待する Hamcrest マッチャーを返します 特定の Hamcrest マッチャ
    • hasProperty() Matchers のメソッド クラスは、アサートされたオブジェクトのプロパティのアサーションを記述できるようにするマッチャーを返します。
    • equalTo() Matchers のメソッド クラスは、実際のプロパティ値が期待値と等しいことを確認できるマッチャーを返します。

    アサーションを書き終えると、次のようになります。

    import org.junit.jupiter.api.BeforeEach;
    import org.junit.jupiter.api.DisplayName;
    import org.junit.jupiter.api.Test;
    
    import static org.hamcrest.MatcherAssert.assertThat;
    import static org.hamcrest.Matchers.allOf;
    import static org.hamcrest.Matchers.equalTo;
    import static org.hamcrest.Matchers.hasProperty;
    
    @DisplayName("Combine multiple assertions")
    class CombineAssertionsTest {
    
        private static final String FIRST_NAME = "Jane";
        private static final String LAST_NAME = "Doe";
    
        private Person person;
    
        @BeforeEach
        void createPerson() {
            person = new Person();
            person.setFirstName(FIRST_NAME);
            person.setLastName(LAST_NAME);
        }
    
        @Test
        @DisplayName("Should have the correct name")
        void shouldHaveCorrectName() {
            assertThat(person, allOf(
                    hasProperty("firstName", equalTo(FIRST_NAME)),
                    hasProperty("lastName", equalTo(LAST_NAME))
            ));
        }
    }
    

    一方、人の名前または姓が正しいことを確認したい場合は、assertThat() に渡される Hamcrest マッチャーを作成する必要があります。 これらの Hamcrest Matcher を使用したメソッド:

    • anyOf() Matchers のメソッド クラスは、アサートされたオブジェクトが any と一致することを期待する Hamcrest マッチャーを返します 指定された Hamcrest マッチャ
    • hasProperty() Matchers のメソッド クラスは、アサートされたオブジェクトのプロパティのアサーションを記述できるようにするマッチャーを返します。
    • equalTo() Matchers のメソッド クラスは、実際のプロパティ値が期待値と等しいことを確認できるマッチャーを返します。

    アサーションを書き終えると、次のようになります。

    import org.junit.jupiter.api.BeforeEach;
    import org.junit.jupiter.api.DisplayName;
    import org.junit.jupiter.api.Test;
    
    import static org.hamcrest.MatcherAssert.assertThat;
    import static org.hamcrest.Matchers.anyOf;
    import static org.hamcrest.Matchers.equalTo;
    import static org.hamcrest.Matchers.hasProperty;
    
    @DisplayName("Combine multiple assertions")
    class CombineAssertionsTest {
    
        private static final String FIRST_NAME = "Jane";
        private static final String LAST_NAME = "Doe";
    
        private Person person;
    
        @BeforeEach
        void createPerson() {
            person = new Person();
            person.setFirstName(FIRST_NAME);
            person.setLastName(LAST_NAME);
        }
    
        @Test
        @DisplayName("Should have correct first name or last name")
        void shouldHaveCorrectFirstNameOrLastName() {
            assertThat(person, anyOf(
                    hasProperty("firstName", equalTo(FIRST_NAME)),
                    hasProperty("lastName", equalTo(LAST_NAME))
            ));
        }
    }
    

    次に、アサーションが失敗したときに表示されるカスタム エラー メッセージを提供する方法を確認します。

    カスタム エラー メッセージの提供

    アサーションが失敗したときに表示されるカスタム エラー メッセージを指定したい場合は、このメッセージを assertThat() の最初のメソッド パラメータとして渡す必要があります。 方法。次の 2 つのオプションのいずれかを使用して、このエラー メッセージを作成できます。

    • エラー メッセージにパラメータがない場合は、String を使用する必要があります 文字通り。
    • エラー メッセージにパラメータがある場合は、static format() を使用する必要があります String のメソッド クラス。

    たとえば、アサートされたリストに特定の要素が含まれていない場合に表示されるエラー メッセージを作成する場合は、次のようなアサーションを作成する必要があります。

    import org.junit.jupiter.api.BeforeEach;
    import org.junit.jupiter.api.DisplayName;
    import org.junit.jupiter.api.Nested;
    import org.junit.jupiter.api.Test;
    
    import java.util.Arrays;
    import java.util.List;
    
    import static org.hamcrest.MatcherAssert.assertThat;
    import static org.hamcrest.Matchers.hasItem;
    
    @DisplayName("Writing assertions for lists")
    class ListAssertionTest {
    
        @Nested
        @DisplayName("When we write assertions for elements")
        class WhenWeWriteAssertionsForElements {
    
            private Object first;
            private Object second;
    
            private List<Object> list;
    
            @BeforeEach
            void createAndInitializeList() {
                first = new Object();
                second = new Object();
    
                list = Arrays.asList(first, second);
            }
    
            @Test
            @DisplayName("Should contain a correct element")
            void shouldContainCorrectElementWithCustomErrorMessage() {
                assertThat(String.format(
                                "The list doesn't contain the expected object: %s", 
                                first
                        ),
                        list,
                        hasItem(first)
                );
            }
        }
    }
    

    Hamcrest を使用して基本的なアサーションを記述し、複数の Hamcrest マッチャーを組み合わせて、アサーションが失敗したときに表示されるカスタム エラー メッセージを提供できるようになりました。

    このブログ投稿から学んだことをまとめましょう。

    まとめ

    このブログ投稿から 4 つのことがわかりました:

    • Hamcrest でアサーションを書く前に、hamcrest-library 依存関係がクラスパスから見つかりました。
    • Hamcrest でアサーションを書きたい場合は、assertThat() を使用する必要があります org.hamcrest.MatcherAssert のメソッド クラス。
    • アサーションが失敗したときに表示されるカスタム エラー メッセージを提供する場合は、このエラー メッセージを assertThat() の最初のメソッド パラメータとして渡す必要があります。 メソッド。
    • Matchers のいくつかのメソッド クラスは Hamcrest マッチャー (またはマッチャー) をメソッド パラメーターとして受け取ることができます。これらのメソッドを使用して、複数の Hamcrest マッチャーを組み合わせることができます。

    Java タグ