Testing with AssertJ Array in Java

Table of Contents

提供驗證元素條件判斷等方法，編寫的測試程式使用流暢的斷言語句，通常與 JUnit 測試一起使用， AssertJ 斷言的基本方法是 assertThat 方法，使用 Testing Java AssertJ Array 流式斷言，本篇增加了範例，並透過單元測試來驗證產出結果。

檔案目錄

./
   +- src
       +- test
       |   +- org
       |       +- ruoxue
       |           +- spring_boot_168
       |               +- test
       |                   +- assertj
       |                       +- array
       |                           +- TestingAssertJArrayTest.java

單元測試

Java AssertJ Array Testing 斷言陣列的主要目的是取得陣列的正確元素以進行斷言。

are

驗證元素是否符合條件判斷，若不成立，則會拋出 AssertionError 。

	@Test
	public void are() {
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		System.out.println(Arrays.toString(array));
		Condition<String> length = new Condition<String>(s -> s.length() > 4, "length");
		assertThat(array).are(length);

		Integer[] intArray = new Integer[] { 1, 2, 3, 4, 5 };
		System.out.println(Arrays.toString(intArray));
		Condition<Integer> intValue = new Condition<Integer>(i -> i > 0, "value");
		assertThat(intArray).are(intValue);
	}

[Durian, Guava, Pitaya]
[1, 2, 3, 4, 5]

areAtLeast

Java AssertJ Array Testing 驗證元素是否符合條件判斷，最少滿足幾個，若不成立，則會拋出 AssertionError 。

	@Test
	public void areAtLeast() {
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		System.out.println(Arrays.toString(array));
		Condition<String> length = new Condition<String>(s -> s.length() > 5, "length");
		assertThat(array).areAtLeast(2, length);

		Integer[] intArray = new Integer[] { 1, 2, 3, 4, 5 };
		System.out.println(Arrays.toString(intArray));
		Condition<Integer> intValue = new Condition<Integer>(i -> i > 1, "value");
		assertThat(intArray).areAtLeast(2, intValue);
	}

[Durian, Guava, Pitaya]
[1, 2, 3, 4, 5]

areAtLeastOne

Java AssertJ Array Testing 驗證元素是否符合條件判斷，最少滿足一個，若不成立，則會拋出 AssertionError 。

	@Test
	public void areAtLeastOne() {
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		System.out.println(Arrays.toString(array));
		Condition<String> length = new Condition<String>(s -> s.length() > 5, "length");
		assertThat(array).areAtLeastOne(length);

		Integer[] intArray = new Integer[] { 1, 2, 3, 4, 5 };
		System.out.println(Arrays.toString(intArray));
		Condition<Integer> intValue = new Condition<Integer>(i -> i >  4, "value");
		assertThat(intArray).areAtLeastOne(intValue);
	}

[Durian, Guava, Pitaya]
[1, 2, 3, 4, 5]

areAtMost

Java AssertJ Array Testing 驗證元素是否符合條件判斷，最多滿足幾個，若不成立，則會拋出 AssertionError 。

	@Test
	public void areAtMost() {
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		System.out.println(Arrays.toString(array));
		Condition<String> length = new Condition<String>(s -> s.length() > 5, "length");
		assertThat(array).areAtMost(2, length);

		Integer[] intArray = new Integer[] { 1, 2, 3, 4, 5 };
		System.out.println(Arrays.toString(intArray));
		Condition<Integer> intValue = new Condition<Integer>(i -> i > 3, "value");
		assertThat(intArray).areAtMost(2, intValue);
	}

[Durian, Guava, Pitaya]
[1, 2, 3, 4, 5]

areExactly

Java Testing AssertJ Array 驗證元素是否符合條件判斷，完全滿足幾個，若不成立，則會拋出 AssertionError 。

	@Test
	public void areExactly() {
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		System.out.println(Arrays.toString(array));
		Condition<String> length = new Condition<String>(s -> s.length() > 5, "length");
		assertThat(array).areExactly(2, length);

		Integer[] intArray = new Integer[] { 1, 2, 3, 4, 5 };
		System.out.println(Arrays.toString(intArray));
		Condition<Integer> intValue = new Condition<Integer>(i -> i > 3, "value");
		assertThat(intArray).areExactly(2, intValue);
	}

[Durian, Guava, Pitaya]
[1, 2, 3, 4, 5]

areNot

Java Testing AssertJ Array 驗證元素不符合條件判斷，若不成立，則會拋出 AssertionError 。

	@Test
	public void areNot() {
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		System.out.println(Arrays.toString(array));
		Condition<String> length = new Condition<String>(s -> s.length() > 6, "length");
		assertThat(array).areNot(length);

		Integer[] intArray = new Integer[] { 1, 2, 3, 4, 5 };
		System.out.println(Arrays.toString(intArray));
		Condition<Integer> intValue = new Condition<Integer>(i -> i > 6, "value");
		assertThat(intArray).areNot(intValue);
	}

[Durian, Guava, Pitaya]
[1, 2, 3, 4, 5]

as

Java Testing AssertJ Array 設定驗證描述，當驗證失敗時，顯示自定義訊息。

	@Test
	public void as() {
		int expectedSize = 2;
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		try {
			assertThat(array).as("%s's length should be equal to 2", "Array").isEqualTo(expectedSize);
		} catch (AssertionError e) {
			e.printStackTrace();
			assertThat(e).hasMessageContaining("length");
		}
	}

org.opentest4j.AssertionFailedError: [Array's length should be equal to 2] 
expected: 2
 but was: ["Durian", "Guava", "Pitaya"]
	at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
	at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
	at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
	at org.ruoxue.spring_boot_168.test.assertj.array.TestingAssertJArrayTest.as(TestingAssertJArrayTest.java:96)

asWithSupplier

Java Testing AssertJ Array 設定驗證描述，當驗證失敗時，顯示自定義訊息。

	@Test
	public void asWithSupplier() {
		int expectedSize = 2;
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		String text = "Length expected: [" + expectedSize + "] but was: [" + array.length + "]";
		try {
			Supplier<String> desc = () -> text;
			assertThat(array).as(desc).hasSize(expectedSize);
		} catch (AssertionError e) {
			e.printStackTrace();
			assertThat(e).hasMessageContaining(text);
		}
	}

java.lang.AssertionError: [Length expected: [2] but was: [3]] 
Expected size: 2 but was: 3 in:
["Durian", "Guava", "Pitaya"]
	at org.ruoxue.spring_boot_168.test.assertj.array.TestingAssertJArrayTest.asWithSupplier(TestingAssertJArrayTest.java:110)

TestingAssertJArrayTest.java

Java Testing AssertJ Array 新增單元測試，驗證是否符合預期。

package org.ruoxue.spring_boot_168.test.assertj.array;

import static org.assertj.core.api.Assertions.assertThat;

import java.util.Arrays;
import java.util.function.Supplier;

import org.assertj.core.api.Condition;
import org.junit.jupiter.api.Test;

public class TestingAssertJArrayTest {

	@Test
	public void are() {
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		System.out.println(Arrays.toString(array));
		Condition<String> length = new Condition<String>(s -> s.length() > 4, "length");
		assertThat(array).are(length);

		Integer[] intArray = new Integer[] { 1, 2, 3, 4, 5 };
		System.out.println(Arrays.toString(intArray));
		Condition<Integer> intValue = new Condition<Integer>(i -> i > 0, "value");
		assertThat(intArray).are(intValue);
	}

	@Test
	public void areAtLeast() {
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		System.out.println(Arrays.toString(array));
		Condition<String> length = new Condition<String>(s -> s.length() > 5, "length");
		assertThat(array).areAtLeast(2, length);

		Integer[] intArray = new Integer[] { 1, 2, 3, 4, 5 };
		System.out.println(Arrays.toString(intArray));
		Condition<Integer> intValue = new Condition<Integer>(i -> i > 1, "value");
		assertThat(intArray).areAtLeast(2, intValue);
	}

	@Test
	public void areAtLeastOne() {
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		System.out.println(Arrays.toString(array));
		Condition<String> length = new Condition<String>(s -> s.length() > 5, "length");
		assertThat(array).areAtLeastOne(length);

		Integer[] intArray = new Integer[] { 1, 2, 3, 4, 5 };
		System.out.println(Arrays.toString(intArray));
		Condition<Integer> intValue = new Condition<Integer>(i -> i > 4, "value");
		assertThat(intArray).areAtLeastOne(intValue);
	}

	@Test
	public void areAtMost() {
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		System.out.println(Arrays.toString(array));
		Condition<String> length = new Condition<String>(s -> s.length() > 5, "length");
		assertThat(array).areAtMost(2, length);

		Integer[] intArray = new Integer[] { 1, 2, 3, 4, 5 };
		System.out.println(Arrays.toString(intArray));
		Condition<Integer> intValue = new Condition<Integer>(i -> i > 3, "value");
		assertThat(intArray).areAtMost(2, intValue);
	}

	@Test
	public void areExactly() {
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		System.out.println(Arrays.toString(array));
		Condition<String> length = new Condition<String>(s -> s.length() > 5, "length");
		assertThat(array).areExactly(2, length);

		Integer[] intArray = new Integer[] { 1, 2, 3, 4, 5 };
		System.out.println(Arrays.toString(intArray));
		Condition<Integer> intValue = new Condition<Integer>(i -> i > 3, "value");
		assertThat(intArray).areExactly(2, intValue);
	}

	@Test
	public void areNot() {
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		System.out.println(Arrays.toString(array));
		Condition<String> length = new Condition<String>(s -> s.length() > 6, "length");
		assertThat(array).areNot(length);

		Integer[] intArray = new Integer[] { 1, 2, 3, 4, 5 };
		System.out.println(Arrays.toString(intArray));
		Condition<Integer> intValue = new Condition<Integer>(i -> i > 6, "value");
		assertThat(intArray).areNot(intValue);
	}

	@Test
	public void as() {
		int expectedSize = 2;
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		try {
			assertThat(array).as("%s's length should be equal to 2", "Array").isEqualTo(expectedSize);
		} catch (AssertionError e) {
			e.printStackTrace();
			assertThat(e).hasMessageContaining("length");
		}
	}

	@Test
	public void asWithSupplier() {
		int expectedSize = 2;
		String[] array = new String[] { "Durian", "Guava", "Pitaya" };
		String text = "Length expected: [" + expectedSize + "] but was: [" + array.length + "]";
		try {
			Supplier<String> desc = () -> text;
			assertThat(array).as(desc).hasSize(expectedSize);
		} catch (AssertionError e) {
			e.printStackTrace();
			assertThat(e).hasMessageContaining(text);
		}
	}
}