Blog

Testing with AssertJ Optional in Java - AssertJ 155

Testing with AssertJ Optional in Java – AssertJ 155

Testing with AssertJ Optional in Java

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

檔案目錄

./
   +- src
       +- test
       |   +- org
       |       +- ruoxue
       |           +- spring_boot_168
       |               +- test
       |                   +- assertj
       |                       +- optional
       |                           +- TestingAssertJOptionalTest.java

單元測試

Java AssertJ Optional Testing 斷言 Optional 的主要目的是取得 Optional 以進行斷言。

map

驗證 Optional 容器內值轉換後是否符合條件，若不成立，則會拋出 AssertionError 。

	@Test
	public void map() {
		Optional<String> value = Optional.of("AssertJ");
		System.out.println(value);
		Function<String, String> upperCase = s -> s.toUpperCase();
		assertThat(value).map(upperCase).contains("ASSERTJ");

		value = Optional.ofNullable(null);
		System.out.println(value);
		assertThat(value).map(upperCase).isEmpty();

		Optional<Integer> intValue = Optional.of(-155);
		System.out.println(intValue);
		Function<Integer, Integer> abs = i -> Math.abs(i);
		assertThat(intValue).map(abs).contains(155);

		intValue = Optional.ofNullable(null);
		System.out.println(intValue);
		assertThat(intValue).map(abs).isEmpty();
	}
Optional[AssertJ]
Optional.empty
Optional[-155]
Optional.empty

flatMap

Java AssertJ Optional Testing 驗證 Optional 容器內值轉換後是否符合條件，若不成立，則會拋出 AssertionError 。

	@Test
	public void flatMap() {
		Optional<String> value = Optional.of("AssertJ");
		System.out.println(value);
		Function<String, Optional<String>> upperCase = s -> s == null ? Optional.empty() : Optional.of(s.toUpperCase());
		assertThat(value).flatMap(upperCase).contains("ASSERTJ");

		value = Optional.ofNullable(null);
		System.out.println(value);
		assertThat(value).flatMap(upperCase).isEmpty();

		Optional<Integer> intValue = Optional.of(-155);
		System.out.println(intValue);
		Function<Integer, Optional<Integer>> abs = i -> i == null ? Optional.empty() : Optional.of(Math.abs(i));
		assertThat(intValue).flatMap(abs).contains(155);

		intValue = Optional.ofNullable(null);
		System.out.println(intValue);
		assertThat(intValue).flatMap(abs).isEmpty();
	}
Optional[AssertJ]
Optional.empty
Optional[-155]
Optional.empty

usingDefaultComparator

Java Testing AssertJ Optional 使用預設比較器，驗證值是否符合條件判斷，若不成立，則會拋出 AssertionError 。

	@Test
	public void usingDefaultComparator() {
		Optional<String> value = Optional.of("AssertJ");
		System.out.println(value);
		assertThat(value).usingDefaultComparator().contains("AssertJ");

		Optional<Integer> intValue = Optional.of(155);
		System.out.println(intValue);
		assertThat(intValue).usingDefaultComparator().contains(155);
	}
Optional[AssertJ]
Optional[155]

usingComparator

Java Testing AssertJ Optional 使用自定義比較器，驗證值是否符合條件判斷，若不成立，則會拋出 AssertionError 。

	@Test
	public void usingComparator() {
		Optional<String> value = Optional.of("AssertJ");
		System.out.println(value);
		Comparator<Optional<String>> ignoreCase = (s1, s2) -> s1.get().toLowerCase().compareTo(s2.get().toLowerCase());
		assertThat(value).usingComparator(ignoreCase).hasValue("AssertJ");

		Optional<Integer> intValue = Optional.of(155);
		System.out.println(intValue);
		Comparator<Optional<Integer>> abs = (i1, i2) -> Double.compare(i1.get(), Math.abs(i2.get()));
		assertThat(intValue).usingComparator(abs).hasValue(155);
	}
Optional[AssertJ]
Optional[155]

usingComparatorWithDescription

Java Testing AssertJ Optional 使用自定義比較器及描述，驗證值是否符合條件判斷，顯示自定義訊息。

	@Test
	public void usingComparatorWithDescription() {
		Optional<String> value = Optional.of("AssertJ");
		System.out.println(value);
		Comparator<Optional<String>> ignoreCase = (s1, s2) -> s1.get().toLowerCase().compareTo(s2.get().toLowerCase());
		assertThat(value).usingComparator(ignoreCase, "ignoreCase").hasValue("AssertJ");

		Optional<Integer> intValue = Optional.of(155);
		System.out.println(intValue);
		Comparator<Optional<Integer>> abs = (i1, i2) -> Double.compare(i1.get(), Math.abs(i2.get()));
		assertThat(intValue).usingComparator(abs, "abs").hasValue(155);
	}
Optional[AssertJ]
Optional[155]

TestingAssertJOptionalTest.java

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

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

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

import java.util.Comparator;
import java.util.Optional;
import java.util.function.Function;

import org.junit.jupiter.api.Test;

public class TestingAssertJOptionalTest {

	@Test
	public void map() {
		Optional<String> value = Optional.of("AssertJ");
		System.out.println(value);
		Function<String, String> upperCase = s -> s.toUpperCase();
		assertThat(value).map(upperCase).contains("ASSERTJ");

		value = Optional.ofNullable(null);
		System.out.println(value);
		assertThat(value).map(upperCase).isEmpty();

		Optional<Integer> intValue = Optional.of(-155);
		System.out.println(intValue);
		Function<Integer, Integer> abs = i -> Math.abs(i);
		assertThat(intValue).map(abs).contains(155);

		intValue = Optional.ofNullable(null);
		System.out.println(intValue);
		assertThat(intValue).map(abs).isEmpty();
	}

	@Test
	public void flatMap() {
		Optional<String> value = Optional.of("AssertJ");
		System.out.println(value);
		Function<String, Optional<String>> upperCase = s -> s == null ? Optional.empty() : Optional.of(s.toUpperCase());
		assertThat(value).flatMap(upperCase).contains("ASSERTJ");

		value = Optional.ofNullable(null);
		System.out.println(value);
		assertThat(value).flatMap(upperCase).isEmpty();

		Optional<Integer> intValue = Optional.of(-155);
		System.out.println(intValue);
		Function<Integer, Optional<Integer>> abs = i -> i == null ? Optional.empty() : Optional.of(Math.abs(i));
		assertThat(intValue).flatMap(abs).contains(155);

		intValue = Optional.ofNullable(null);
		System.out.println(intValue);
		assertThat(intValue).flatMap(abs).isEmpty();
	}

	@Test
	public void usingDefaultComparator() {
		Optional<String> value = Optional.of("AssertJ");
		System.out.println(value);
		assertThat(value).usingDefaultComparator().contains("AssertJ");

		Optional<Integer> intValue = Optional.of(155);
		System.out.println(intValue);
		assertThat(intValue).usingDefaultComparator().contains(155);
	}

	@Test
	public void usingComparator() {
		Optional<String> value = Optional.of("AssertJ");
		System.out.println(value);
		Comparator<Optional<String>> ignoreCase = (s1, s2) -> s1.get().toLowerCase().compareTo(s2.get().toLowerCase());
		assertThat(value).usingComparator(ignoreCase).hasValue("AssertJ");

		Optional<Integer> intValue = Optional.of(155);
		System.out.println(intValue);
		Comparator<Optional<Integer>> abs = (i1, i2) -> Double.compare(i1.get(), Math.abs(i2.get()));
		assertThat(intValue).usingComparator(abs).hasValue(155);
	}

	@Test
	public void usingComparatorWithDescription() {
		Optional<String> value = Optional.of("AssertJ");
		System.out.println(value);
		Comparator<Optional<String>> ignoreCase = (s1, s2) -> s1.get().toLowerCase().compareTo(s2.get().toLowerCase());
		assertThat(value).usingComparator(ignoreCase, "ignoreCase").hasValue("AssertJ");

		Optional<Integer> intValue = Optional.of(155);
		System.out.println(intValue);
		Comparator<Optional<Integer>> abs = (i1, i2) -> Double.compare(i1.get(), Math.abs(i2.get()));
		assertThat(intValue).usingComparator(abs, "abs").hasValue(155);
	}
}

心得分享

AssertJ Optional Java Testing 除了提供流式判斷，還針對 Optional 做特殊判斷，在許多測試驗證的場景，讓開發者使用更流暢的驗證，不需要再寫迴圈，善用 Java Testing AssertJ Optional 將有助於驗證效率的提升。

原碼下載

Tags: , , , , ,

發佈留言