Blog

Testing with AssertJ Object in Java - AssertJ 155

Testing with AssertJ Object in Java – AssertJ 155

Testing with AssertJ Object in Java

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

檔案目錄

./
   +- src
       +- test
       |   +- org
       |       +- ruoxue
       |           +- spring_boot_168
       |               +- test
       |                   +- assertj
       |                       +- object
       |                           +- TestingAssertJObjectTest.java

單元測試

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

Fruit

建立 Fruit 類別，覆寫 toString ，定義屬性和方法，用來建立一個物件。

	@NoArgsConstructor
	@Getter
	@Setter
	public static class Fruit {
		private String name;
		private double quantity;
		private int type;
		private List<String> origins = new ArrayList<>();

		public Fruit(String name, double quantity, int type) {
			this.name = name;
			this.quantity = quantity;
			this.type = type;
		}

		public String toString() {
			ToStringBuilder builder = new ToStringBuilder(this, ToStringStyle.JSON_STYLE);
			builder.appendSuper(super.toString());
			builder.append("name", name);
			builder.append("quantity", quantity);
			builder.append("type", type);
			builder.append("origins", origins);
			return builder.toString();
		}
	}

isLessThan

驗證物件是否小於指定值，若不成立，則會拋出 AssertionError 。

	@Test
	public void isLessThan() {
		Object value = new Fruit("Pomelo", 1, 2);
		System.out.println(value);
		assertThat(value).extracting("type").asInstanceOf(INTEGER).isLessThan(3);
		assertThat(value).extracting("quantity").asInstanceOf(DOUBLE).isLessThan(2d);
	}
{"name":"Pomelo","quantity":1.0,"type":2}

isLessThanOrEqualTo

Java AssertJ Object Testing 驗證物件是否小於或等於指定值，若不成立，則會拋出 AssertionError 。

	@Test
	public void isLessThanOrEqualTo() {
		Object value = new Fruit("Pomelo", 1, 2);
		System.out.println(value);
		assertThat(value).extracting("type").asInstanceOf(INTEGER).isLessThanOrEqualTo(2).isLessThanOrEqualTo(3);
		assertThat(value).extracting("quantity").asInstanceOf(DOUBLE).isLessThanOrEqualTo(1d).isLessThanOrEqualTo(2d);
	}
{"name":"Pomelo","quantity":1.0,"type":2}

isGreaterThan

Java AssertJ Object Testing 驗證物件是否大於指定值，若不成立，則會拋出 AssertionError 。

	@Test
	public void isGreaterThan() {
		Object value = new Fruit("Pomelo", 1, 2);
		System.out.println(value);
		assertThat(value).extracting("type").asInstanceOf(INTEGER).isGreaterThan(1);
		assertThat(value).extracting("quantity").asInstanceOf(DOUBLE).isGreaterThan(0d);
	}
{"name":"Pomelo","quantity":1.0,"type":2}

isGreaterThanOrEqualTo

Java AssertJ Object Testing 驗證物件是否大於或等於指定值，若不成立，則會拋出 AssertionError 。

	@Test
	public void isGreaterThanOrEqualTo() {
		Object value = new Fruit("Pomelo", 1, 2);
		System.out.println(value);
		assertThat(value).extracting("type").asInstanceOf(INTEGER).isGreaterThanOrEqualTo(2).isGreaterThanOrEqualTo(1);
		assertThat(value).extracting("quantity").asInstanceOf(DOUBLE).isGreaterThanOrEqualTo(1d)
				.isGreaterThanOrEqualTo(0d);
	}
{"name":"Pomelo","quantity":1.0,"type":2}

usingDefaultComparator

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

	@Test
	public void usingDefaultComparator() {
		Object value = new Fruit("Pomelo", 1, 2);
		System.out.println(value);
		assertThat(value).extracting("type").asInstanceOf(INTEGER).isPositive().isCloseTo(-3, within(5)).isCloseTo(7,
				within(5));
		assertThat(value).extracting("quantity").asInstanceOf(DOUBLE).isPositive().isCloseTo(-4d, within(5d))
				.isCloseTo(-4d, within(6d));
	}
{"name":"Pomelo","quantity":1.0,"type":2}

usingComparator

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

	@Test
	public void usingComparator() {
		Object value = new Fruit("Pomelo", 1, 2);
		System.out.println(value);
		Comparator<Integer> abs = (i1, i2) -> Integer.compare(i1, Math.abs(i2));
		assertThat(value).extracting("type").asInstanceOf(INTEGER).usingComparator(abs).isEqualTo(-2);

		Comparator<Double> doubleAbs = (d1, d2) -> Double.compare(d1, Math.abs(d2));
		assertThat(value).extracting("quantity").asInstanceOf(DOUBLE).usingComparator(doubleAbs).isEqualTo(-1d);
	}
{"name":"Pomelo","quantity":1.0,"type":2}

usingComparatorWithDescription

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

	@Test
	public void usingComparatorWithDescription() {
		Object value = new Fruit("Pomelo", 1, 2);
		System.out.println(value);
		Comparator<Integer> abs = (i1, i2) -> Integer.compare(i1, Math.abs(i2));
		assertThat(value).extracting("type").asInstanceOf(INTEGER).usingComparator(abs, "abs").isEqualTo(-2);

		Comparator<Double> doubleAbs = (d1, d2) -> Double.compare(d1, Math.abs(d2));
		assertThat(value).extracting("quantity").asInstanceOf(DOUBLE).usingComparator(doubleAbs, "doubleAbs")
				.isEqualTo(-1d);
	}
{"name":"Pomelo","quantity":1.0,"type":2}

TestingAssertJObjectTest.java

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

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

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

import java.util.Comparator;

import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
import org.junit.jupiter.api.Test;

import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

public class TestingAssertJObjectTest {

	@NoArgsConstructor
	@Getter
	@Setter
	public static class Fruit {
		private String name;
		private double quantity;
		private int type;

		public Fruit(String name, double quantity, int type) {
			this.name = name;
			this.quantity = quantity;
			this.type = type;
		}

		public String toString() {
			ToStringBuilder builder = new ToStringBuilder(this, ToStringStyle.JSON_STYLE);
			builder.appendSuper(super.toString());
			builder.append("name", name);
			builder.append("quantity", quantity);
			builder.append("type", type);
			return builder.toString();
		}
	}

	@Test
	public void isLessThan() {
		Object value = new Fruit("Pomelo", 1, 2);
		System.out.println(value);
		assertThat(value).extracting("type").asInstanceOf(INTEGER).isLessThan(3);
		assertThat(value).extracting("quantity").asInstanceOf(DOUBLE).isLessThan(2d);
	}

	@Test
	public void isLessThanOrEqualTo() {
		Object value = new Fruit("Pomelo", 1, 2);
		System.out.println(value);
		assertThat(value).extracting("type").asInstanceOf(INTEGER).isLessThanOrEqualTo(2).isLessThanOrEqualTo(3);
		assertThat(value).extracting("quantity").asInstanceOf(DOUBLE).isLessThanOrEqualTo(1d).isLessThanOrEqualTo(2d);
	}

	@Test
	public void isGreaterThan() {
		Object value = new Fruit("Pomelo", 1, 2);
		System.out.println(value);
		assertThat(value).extracting("type").asInstanceOf(INTEGER).isGreaterThan(1);
		assertThat(value).extracting("quantity").asInstanceOf(DOUBLE).isGreaterThan(0d);
	}

	@Test
	public void isGreaterThanOrEqualTo() {
		Object value = new Fruit("Pomelo", 1, 2);
		System.out.println(value);
		assertThat(value).extracting("type").asInstanceOf(INTEGER).isGreaterThanOrEqualTo(2).isGreaterThanOrEqualTo(1);
		assertThat(value).extracting("quantity").asInstanceOf(DOUBLE).isGreaterThanOrEqualTo(1d)
				.isGreaterThanOrEqualTo(0d);
	}

	@Test
	public void usingDefaultComparator() {
		Object value = new Fruit("Pomelo", 1, 2);
		System.out.println(value);
		assertThat(value).extracting("type").asInstanceOf(INTEGER).isPositive().isCloseTo(-3, within(5)).isCloseTo(7,
				within(5));
		assertThat(value).extracting("quantity").asInstanceOf(DOUBLE).isPositive().isCloseTo(-4d, within(5d))
				.isCloseTo(-4d, within(6d));
	}

	@Test
	public void usingComparator() {
		Object value = new Fruit("Pomelo", 1, 2);
		System.out.println(value);
		Comparator<Integer> abs = (i1, i2) -> Integer.compare(i1, Math.abs(i2));
		assertThat(value).extracting("type").asInstanceOf(INTEGER).usingComparator(abs).isEqualTo(-2);

		Comparator<Double> doubleAbs = (d1, d2) -> Double.compare(d1, Math.abs(d2));
		assertThat(value).extracting("quantity").asInstanceOf(DOUBLE).usingComparator(doubleAbs).isEqualTo(-1d);
	}

	@Test
	public void usingComparatorWithDescription() {
		Object value = new Fruit("Pomelo", 1, 2);
		System.out.println(value);
		Comparator<Integer> abs = (i1, i2) -> Integer.compare(i1, Math.abs(i2));
		assertThat(value).extracting("type").asInstanceOf(INTEGER).usingComparator(abs, "abs").isEqualTo(-2);

		Comparator<Double> doubleAbs = (d1, d2) -> Double.compare(d1, Math.abs(d2));
		assertThat(value).extracting("quantity").asInstanceOf(DOUBLE).usingComparator(doubleAbs, "doubleAbs")
				.isEqualTo(-1d);
	}
}

心得分享

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

原碼下載

Tags: , , , , ,

發佈留言