AssertJ版：テストでよく使う検証メソッド一覧

# はじめに

[AssertJ ～Fluent assertions for java～](http://joel-costigliola.github.io/assertj/index.html)

JUnit でよく使う Matcher はこちらによくまとまっています。
[HamcrestのMatchersに定義されているメソッドの使い方メモ](http://qiita.com/opengl-8080/items/e57dab6e1fa5940850a3)

今回はこれの AssertJ 版的な位置づけで用意してみようと思います。
ただし、全ての検証メソッドを網羅しているわけではありませんので、その点についてはご容赦下さい。

# バージョン

## Java
1.8

## AssertJ
3.2.0

# 基本的な比較
https://gist.github.com/naotawool/b3d3903dfd3d17c51573#file-assertjbasiclearning-java

## isEqualTo/isNotEqualTo: 同値検証

```java:AssertJBasicLearning.java
@Test
public void 同値検証() {
    assertThat("Foo").isEqualTo("Foo");
    assertThat("Foo").isNotEqualTo("Bar");
}
```

## isNull/isNotNull: Null 検証

```java:AssertJBasicLearning.java
@Test
public void null検証() {
    Object actual = null;
    assertThat(actual).isNull();

    actual = "Foo";
    assertThat(actual).isNotNull();
}
```

## isEqualByComparingTo/isNotEqualByComparingTo: compareToによる検証

```java:AssertJBasicLearning.java
@Test
public void compareToによる検証() {
    Foo foo1 = new Foo();
    Foo foo2 = new Foo();

    assertThat(foo1).isEqualByComparingTo(foo2);
}

private static final class Foo implements Comparable<Foo> {
    @Override
    public int compareTo(Foo other) {
        return 0;
    }
}
```

## isSameAs/isNotSameAs: 同一インスタンス検証

```java:AssertJBasicLearning.java
@Test
public void インスタンス検証() {
    Bar bar1 = new Bar();
    Bar bar2 = bar1;

    assertThat(bar1).isSameAs(bar2);
}

private static class Bar { }
```

## isInstanceOf/isNotInstanceOf: インスタンス型検証

```java:AssertJBasicLearning.java
@Test
public void 型検証() {
    Baz baz = new Baz();
    Qux qux = new Qux();

    assertThat(baz).isInstanceOf(Baz.class);
    assertThat(qux).isInstanceOf(Baz.class).isInstanceOf(Qux.class);
}

private static class Baz { }
private static final class Qux extends Baz { }
```

## hasToString: toString 検証

```java:AssertJBasicLearning.java
@Test
public void toStringによる検証() {
    FooBar fooBar = new FooBar();

    assertThat(fooBar).hasToString("FooBar");
}

private static final class FooBar {
    @Override
    public String toString() {
        return "FooBar";
    }
}
```

## as: 検証内容の注釈

```java:AssertJBasicLearning.java
@Test
public void 失敗時に表示される検証内容を設定() {
    assertThat("Foo").as("AssertJ sample").isEqualTo("Bar");

    // org.junit.ComparisonFailure: [AssertJ sample] expected:<"[Bar]"> but was:<"[Foo]">
}
```


# 文字列比較
https://gist.github.com/naotawool/b3d3903dfd3d17c51573#file-assertjstringlearning-java

## startsWith: 接頭辞検証

```java:AssertJStringLearning.java
@Test
public void 接頭辞検証() {
    assertThat("FooBar").startsWith("Foo");
}
```

## endsWith: 接尾辞検証

```java:AssertJStringLearning.java
@Test
public void 接尾辞検証() {
    assertThat("FooBar").endsWith("Bar");
}
```


## isEqualToIgnoringCase: 大文字小文字を無視した検証

```java:AssertJStringLearning.java
@Test
public void 大文字小文字検証検証() {
    assertThat("Foo").isNotEqualTo("FOO").isEqualToIgnoringCase("FOO");
}
```


## isEqualToIgnoringWhitespace: 空白を無視した検証
- タブ (\t) も 1 つのスペースとしてカウントされる
- 先頭と末尾のスペースは無視される
- 複数のスペースは 1 つにまとめられる
- 大文字小文字は無視しない

```java:AssertJStringLearning.java
@Test
public void スペース無視検証() {
    assertThat("Foo BAR baz").isEqualToIgnoringWhitespace(" Foo   BAR\tbaz ");
    assertThat(" Foo   BAR\tbaz ").isEqualToIgnoringWhitespace("Foo BAR baz");
}
```


## isEmpty: 空文字検証

```java:AssertJStringLearning.java
@Test
public void 空文字検証() {
    assertThat("").isEmpty();
}
```


## isNullOrEmpty: 空文字 Null 検証

```java:AssertJStringLearning.java
@Test
public void 空文字null検証() {
    String actual = "";
    assertThat(actual).isNullOrEmpty();

    actual = null;
    assertThat(actual).isNullOrEmpty();
}
```


## matches: 正規表現を使った検証

```java:AssertJStringLearning.java
@Test
public void 正規表現検証() {
    String actual = "FooBarBaz";
    assertThat(actual).matches("F..B..B..").matches("F.*z");
}
```


## containsOnlyDigits: 数字検証

```java:AssertJStringLearning.java
@Test
public void 数字検証() {
    String actual = "1234567890";
    assertThat(actual).containsOnlyDigits();
}
```


## hasLineCount: 行数検証

```java:AssertJStringLearning.java
@Test
public void 行数検証() {
    String actual = "foo";
    assertThat(actual).hasLineCount(1);

    actual = "foo\nbar\nbaz";
    assertThat(actual).hasLineCount(3);

    actual = "foo\r\nbar\r\nbaz";
    assertThat(actual).hasLineCount(3);
}
```



# 数値比較
https://gist.github.com/naotawool/b3d3903dfd3d17c51573#file-assertjnumberlearning-java

## isBetween: 範囲検証
- 指定した値を含む

```java:AssertJNumberLearning.java
@Test
public void 範囲検証() {
    assertThat(7).isBetween(0, 9).isBetween(7, 7);
    assertThat(7).isCloseTo(5, within(2)); // 5 ± 2 -> OK
    assertThat(7).isCloseTo(5, within(1)); // 5 ± 1 -> NG
}
```

## isGreaterThan/isGreaterThanOrEqualTo: 大なり検証

```java:AssertJNumberLearning.java
@Test
public void 大なり検証() {
    assertThat(7).isGreaterThan(6).isGreaterThanOrEqualTo(7);
}
```


## isLessThan/isLessThanOrEqualTo: 小なり検証

```java:AssertJNumberLearning.java
@Test
public void なり検証() {
    assertThat(7).isLessThan(8).isLessThanOrEqualTo(7);
}
```



# Collection 比較
https://gist.github.com/naotawool/b3d3903dfd3d17c51573#file-assertjcollectionlearning-java

## contains
- 並び順は検証しない
- 期待値に検証対象の値が全て含まれていなくても OK

```java:AssertJCollectionLearning.java
@Test
public void contains() {
    List<String> actuals = Lists.newArrayList("Lucy", "Debit", "Anna", "Jack");

    // 並び順は検証しない
    // 期待値に検証対象の値が全て含まれていなくても OK
    assertThat(actuals).contains("Debit", "Lucy", "Anna")
                       .contains("Lucy", "Anna");
}
```

## containsOnly
- 並び順は検証しない
- 期待値に検証対象の値が全て含まれていないと NG

```java:AssertJCollectionLearning.java
@Test
public void containsOnly() {
    List<String> actuals = Lists.newArrayList("Lucy", "Debit", "Anna", "Jack");

    // 並び順は検証しない
    // 期待値に検証対象の値が全て含まれていないと NG
    assertThat(actuals).containsOnly("Debit", "Lucy", "Jack", "Anna");
}
```



## containsSequence
- 並び順を検証
- 期待値と検証対象の件数は検証しない

```java:AssertJCollectionLearning.java
@Test
public void containsSequence() {
    List<String> actuals = Lists.newArrayList("Lucy", "Debit", "Anna", "Jack");

    // 並び順を検証
    // 期待値と検証対象の件数は検証しない
    assertThat(actuals).containsSequence("Lucy", "Debit")
                       .containsSequence("Debit", "Anna", "Jack");
}
```



## containsSubsequence
- 並び順を検証
- 期待値と検証対象の件数は検証しない
- 期待値に検証対象の抜け盛れがあった場合でも OK

```java:AssertJCollectionLearning.java
@Test
public void containsSubsequence() {
    List<String> actuals = Lists.newArrayList("Lucy", "Debit", "Anna", "Jack");

    // 並び順を検証
    // 期待値と検証対象の件数は検証しない
    // 期待値に検証対象の抜け盛れがあった場合でも OK
    assertThat(actuals).containsSubsequence("Lucy", "Anna")
                       .containsSubsequence("Debit", "Jack")
                       .containsSubsequence("Lucy", "Jack");
}
```



## containsExactly
- 並び順を検証
- 期待値と検証対象の件数も検証

```java:AssertJCollectionLearning.java
@Test
public void containsExactly() {
    List<String> actuals = Lists.newArrayList("Lucy", "Debit", "Anna", "Jack");

    // 並び順を検証
    // 期待値と検証対象の件数も検証
    assertThat(actuals).containsExactly("Lucy", "Debit", "Anna", "Jack");
}
```


## containsNull
- 検証対象に null が含まれていることを検証

```java:AssertJCollectionLearning.java
@Test
public void containsNull() {
    List<String> actuals = Lists.newArrayList("Lucy", null, "Anna", "Jack");

    // 検証対象に null が含まれていることを検証
    assertThat(actuals).containsNull();
}
```


## containsOnlyOnce
- 期待値が検証対象に 1 つだけ含まれることを検証
- 期待値が検証対象に 2 つ以上含まれる、もしくは 1 つも含まれないと NG

```java:AssertJCollectionLearning.java
@Test
public void containsOnlyOnce() {
    List<String> actuals = Lists.newArrayList("Lucy", "Debit", "Anna", "Lucy");

    // 期待値が検証対象に 1 つだけ含まれることを検証
    // 期待値が検証対象に 2 つ以上含まれる、もしくは 1 つも含まれないと NG
    assertThat(actuals).containsOnlyOnce("Debit", "Anna");
}
```


## hasSize: 件数検証

```java:AssertJCollectionLearning.java
@Test
public void 件数検証() {
    List<String> actuals = Lists.newArrayList("Lucy", "Debit", "Anna", "Jack");
    assertThat(actuals).hasSize(4);
}
```


## isEmpty: 空検証

```java:AssertJCollectionLearning.java
@Test
public void 空検証() {
    List<String> actuals = Lists.newArrayList();
    assertThat(actuals).isEmpty();
}
```



# Map 検証
https://gist.github.com/naotawool/b3d3903dfd3d17c51573#file-assertjmaplearning-java

## containsEntry/doesNotContainEntry: Entry 検証

```java:AssertJMapLearning.java
@Test
public void Entry検証() {
    Map<String, Integer> actuals = Maps.newHashMap();
    actuals.put("Key1", 101);
    actuals.put("Key2", 202);
    actuals.put("Key3", 303);

    assertThat(actuals).containsEntry("Key1", 101)
                       .containsEntry("Key2", 202)
                       .doesNotContainEntry("Key9", 999);
}
```


## containsKey/doesNotContainKey: Key 検証

```java:AssertJMapLearning.java
@Test
public void Key検証() {
    Map<String, Integer> actuals = Maps.newHashMap();
    actuals.put("Key1", 101);
    actuals.put("Key2", 202);
    actuals.put("Key3", 303);

    assertThat(actuals).containsKey("Key1")
                       .containsKeys("Key2", "Key3")
                       .doesNotContainKey("Key9");
}
```


## containsValue/doesNotContainValue: Value 検証

```java:AssertJMapLearning.java
@Test
public void Value検証() {
    Map<String, Integer> actuals = Maps.newHashMap();
    actuals.put("Key1", 101);
    actuals.put("Key2", 202);
    actuals.put("Key3", 303);

    assertThat(actuals).containsValue(101)
                       .containsValues(202, 303)
                       .doesNotContainValue(999);
}
```


## hasSize: 件数検証

```java:AssertJMapLearning.java
@Test
public void 件数検証() {
    Map<String, Integer> actuals = Maps.newHashMap();
    actuals.put("Key1", 101);
    actuals.put("Key2", 202);
    actuals.put("Key3", 303);

    assertThat(actuals).hasSize(3);
}
```


## isEmpty: 空検証

```java:AssertJMapLearning.java
@Test
public void 空検証() {
    Map<String, Integer> actuals = Maps.newHashMap();
    assertThat(actuals).isEmpty();
}
```



# 配列検証
https://gist.github.com/naotawool/b3d3903dfd3d17c51573#file-assertjarraylearning-java

AssertJ では、配列の検証において Collection 検証で使用できるメソッド名と同名のものが定義されているのでそちらを使う。


# おわりに
このように、基本的な検証メソッドは AssertJ にも用意されているので、JUnit4 からの乗り換えも可能です。
参考にしてみてください。

次回は カスタム Assertion や SoftAssertions などを取り上げる予定です。