走进Java接口测试之流式断言库AssertJ

Posted 2021-09-29 高楼（Zee）

前言

在设计自动化接口 Cases 时，遵守的核心原则是3A（Arrange-> Actor ->Assert）原则;

断言工具是否强大直接影响到用例的执行效率，本文将介绍目前主流的一种流式断言神器：AssertJ。

AssertJ简介

什么是流式，常见的断言器一条断言语句只能对实际值断言一个校验点，而流式断言器，支持一条断言语句对实际值同时断言多个校验点，简单理解，即 AssertJ 断言是可以串接的。 

AssertJ 是一个 Java 库，为 JDK 标准类型提供断言，可以与 JUnit，TestNG 或任何其他测试框架一起使用。 不同的 AssertJ 主要版本依赖于不同的 Java 版本：

• AssertJ 3.x 需要 Java 8或更高版本
• AssertJ 2.x 需要 Java 7或更高版本
• AssertJ 1.x 需要 Java 6或更高版本

请注意，AssertJ 3.x包含所有AssertJ 2.x功能，并添加了Java 8特定功能（如 lambdas 的异常断言）

AssertJ 支持如下模块：

• Core：AssertJ core is a Java library that provides a fluent interface for writing assertions.
• Assertions generator：Use the Assertion Generator to create assertions specific to your own classes.
• Guava：AssertJ assertions for Guava provides assertions for Guava types like Multimap, Table, Optional, Range or ByteSource.
• Joda-Time：AssertJ assertions for Joda-Time provides assertions for Joda-Time types like DateTime and LocalDateTime.
• DB：AssertJ-DB provides assertions to test data in a database.
• Neo4j：Provides assertions for Neo4j 3 or higher.
• Swing：AssertJ Swing is a Java library that provides a fluent interface for functional Swing UI testing.

官方网站上提供了所有模块的详细列表。 

地址：https://joel-costigliola.github.io/assertj/index.html

让我们从几个例子开始，直接来自 AssertJ 的官方文档：

1. assertThat(frodo)

2.   .isNotEqualTo(sauron)

3.   .isIn(fellowshipOfTheRing);

4. 

5. assertThat(frodo.getName())

6.   .startsWith("Fro")

7.   .endsWith("do")

8.   .isEqualToIgnoringCase("frodo");

9. 

10. assertThat(fellowshipOfTheRing)

11.   .hasSize(9)

12.   .contains(frodo, sam)

13.   .doesNotContain(sauron);

以上的例子只是冰山一角，下面我们将介绍如何使用这个库编写断言

AssertJ使用

导包

SpringBoot 内置了 AssertJ,只需要导入 ​​spring-boot-starter-test​​ 依赖包

1.  <dependencies>

2.         <!--引入效率插件-->

3.         <dependency>

4.             <groupId>org.projectlombok</groupId>

5.             <artifactId>lombok</artifactId>

6.             <optional>true</optional>

7.         </dependency>

8.         <!--引入测试包-->

9.         <dependency>

10.             <groupId>org.springframework.boot</groupId>

11.             <artifactId>spring-boot-starter-test</artifactId>

12.         </dependency>

13.         <!--引入testng测试框架-->

14.         <dependency>

15.             <groupId>org.testng</groupId>

16.             <artifactId>testng</artifactId>

17.             <version>6.14.3</version>

18.         </dependency>

19.     </dependencies>

入门使用

为了编写一个断言，你总是需要先将对象传递给 ​​Assertions.assertThat()​​ 方法，然后再按照实际的断言进行操作。

重要的是要记住，与其他一些库不同，下面的代码实际上并没有断言任何东西，并且永远不会失败测试：

1. assertThat(anyRefenceOrValue);

如果你使用IDE的代码完成功能，由于其描述性非常强的方法，编写AssertJ 断言变得异常简单。下图就是它在 ​​IntelliJIDEA​​ 中的样子： 如图所见，有许多可供选择的上下文方法，并且这些方法仅适用于String类型。

对象断言

可以以各种方式比较对象，以确定两个对象的相等性或检查对象的字段。

1. @Data

2. @Builder

3. @NoArgsConstructor

4. @AllArgsConstructor

5. public class Dog {

6.     private String name;

7.     private Float weight;

8. 

9. }

让我们看两种方法，我们可以比较两个对象的相等性。鉴于以下两个Dog对象 fido和 fidosClone

1. @Test(description = "对象断言1")

2.     public void whenComparingReferences_thenNotEqual() {

3. 

4.         // 实例化两个对象

5.         Dog fidos= new Dog("fidos",5.14f);

6.         Dog fidosClone = new Dog("fidosClone",5.14f);

7. 

8.         // 断言两个对象引用

9.         assertThat(fidos).isNotEqualTo(fidosClone);

10. 

11.     }

​​isEqualTo()​​ 是比较对象引用，所以会执行失败。如果我们想要比较它们的内容，我们可以使用 ​​isEqualToComparingFieldByFieldRecursively()​​

1. @Test(description = "对象断言2")

2.     public void whenComparingFields_thenEqual() {

3.         // 实例化两个对象

4.         Dog fido = new Dog("Fido", 5.15f);

5.         Dog fidosClone = new Dog("Fido", 5.15f);

6. 

7.         // 断言两个对象内容

8.         assertThat(fido).isEqualToComparingFieldByFieldRecursively(fidosClone);

9.     }

当通过字段比较执行递归字段时，Fido和fidosClone是相等的，因为一个对象的每个字段与另一个对象中的字段进行比较。

还有许多其他断言方法提供了比较和收缩对象以及检查和断言其字段的不同方法。具体请参阅官方的 ​​AbstractObjectAssert​​ API。

布尔断言

真值测试有一些简单的方法：

• isTrue()
• isFalse()

举个例子：

1.     @Test(description = "布尔断言")

2.     public void whenisEmpty_isTrue() {

3.         // 实例化对象

4.         Dog fido = new Dog("Fido", 5.15f);

5. 

6.         // 断言字段是否为空

7.         assertThat(fido.getName().isEmpty()).isTrue();

8.     }

Iterable/Array断言

对于 Iterable 或 Array，有多种方法可以断言它们的内容是否存在。最常见的断言之一是检查 Iterable 或 Array 是否包含给定元素：

或者如果 List 不为空：

1. assertThat(list).isNotEmpty();

或者如果 List 以给定字符开头。例如“1”：

1. assertThat(list).startsWith("1");

如果要为同一对象创建多个断言，可以轻松地将它们连接在一起。 下面是一个断言示例，它检查提供的列表是否为空，包含“1”元素，不包含任何空值并包含元素序列“2”，“3”：

1. assertThat(list)

2.   .isNotEmpty()

3.   .contains("1")

4.   .doesNotContainNull()

5.   .containsSequence("2", "3");

当然，对于那些类型存在更多可能的断言 。具体请参阅官方的 ​​AbstractIterableAssert​​ API

完整示例：

1. @Test(description = "Iterable/Array断言1")

2.     public void whenCheckingForElement_thenContains(){

3.         List<String> list = Arrays.asList("1", "2", "3");

4. 

5.         // 断言是否包含给定元素

6.         assertThat(list).contains("1");

7.     }

8. 

9.     @Test(description = "Iterable/Array断言2")

10.     public void whenCheckingForElement_thenMultipleAssertions() {

11.         List<String> list = Arrays.asList("1", "2", "3");

12. 

13.         // 断言list不为空

14.         assertThat(list).isNotEmpty();

15.         // 断言list以给定字段开头

16.         assertThat(list).startsWith("1");

17.         // 断言list不包含null

18.         assertThat(list).doesNotContainNull();

19.         // 多个断言

20.         assertThat(list).isNotEmpty().contains("1").startsWith("1").doesNotContainNull().containsSequence("2", "3");

21.     }

字符断言

字符类型的断言主要涉及比较，甚至检查给定字符是否来自 Unicode 表。 下面是一个断言示例，它检查提供的字符是否不是 \'a\'，在 Unicode 表中，是否大于 \'b\' 并且是小写的：

1. assertThat(someCharacter)

2.   .isNotEqualTo(\'a\')

3.   .inUnicode()

4.   .isGreaterThanOrEqualTo(\'b\')

5.   .isLowerCase();

有关所有字符类型断言的详细列表，请参阅 ​​AbstractCharacterAssert​​ API 

完整示例：

1. @Test(description = "字符断言")

2.     public void whenCheckingCharacter_thenIsUnicode() {

3.         char someCharacter = \'c\';

4. 

5.         // 断言字符是否不是 \'a\'，在 Unicode 表中，是否大于 \'b\' 并且是小写的

6.         assertThat(someCharacter).isNotEqualTo(\'a\').inUnicode().isGreaterThanOrEqualTo(\'b\').isLowerCase();

7.     }

类断言

Class 类型的断言主要是检查其字段，类类型，注释的存在和类的最终性。

如果你想断言Runnable类是一个接口，你需要简单地写：

1. assertThat(Runnable.class).isInterface();

或者如果你想检查一个类是否可以从另一个类中分配：

1. assertThat(Exception.class).isAssignableFrom(NoSuchElementException.class);

可以在 ​​AbstractClassAssert​​ API 中查看所有可能的类断言。 

完整示例：

1. @Test(description = "类断言1")

2.     public void whenCheckingRunnable_thenIsInterface() {

3.         // 断言Runnable类是一个接口

4.         assertThat(Runnable.class).isInterface();

5.     }

6. 

7.     @Test(description = "类断言2")

8.     public void whenAssigningNSEExToException_thenIsAssignable(){

9.         // 断言一个类是否可以从另一个类中分配

10.         assertThat(Exception.class).isAssignableFrom(NoSuchElementException.class);

11.     }

文件断言

文件断言都是关于检查给定的文件实例是否存在，是目录还是文件，具有某些内容，是否可读或具有扩展名。

在这里断言的示例，该断言检查给定文件是否存在，是文件而不是目录，可读写的：

1. assertThat(someFile)

2.   .exists()

3.   .isFile()

4.   .canRead()

5.   .canWrite();

可以在 ​​AbstractFileAssert​​ API 中查看所有可能的类断言。

完整示例：

1. @Test(description = "文件断言")

2.     public void whenCheckingFile_then() throws IOException {

3.         final File someFile = File.createTempFile("aaa", "bbb");

4.         someFile.deleteOnExit();

5. 

6.         // 断言文件是否存在，是文件而不是目录，可读写的

7.         assertThat(someFile).exists().isFile().canRead().canWrite();

8.     }

Double/Float/Integer断言

数字断言都是关于比较给定偏移量内或没有给定偏移量的数值。 例如，如果要根据给定的精度检查两个值是否相等，我们可以执行以下操作：

1. assertThat(5.1).isEqualTo(5, withPrecision(1d));

请注意，我们使用已导入的 withPrecision（双偏移）辅助方法来生成偏移对象。

有关更多断言，请访问 ​​AbstractDoubleAssert​​ API。

InputStream断言

只有一个可用的 InputStream 特定断言：

• hasSameContentAs（预期的 InputStream）

使用方法：

1. assertThat(given).hasSameContentAs(expected);

完整示例：

1. @Test(description = "InputStream断言")

2.     public void whenCheckingIS_then() {

3.         InputStream given = new ByteArrayInputStream("foo".getBytes());

4.         InputStream expected = new ByteArrayInputStream("foo".getBytes());

5. 

6.         // 断言是否预期的 InputStream

7.         assertThat(given).hasSameContentAs(expected);

8.     }

Map断言

Map 断言允许你分别检查 Map 是否包含某些条目，条目集或键/值。 你可以看到断言的示例，该断言检查给定的Map是否为空，包含key “2”，不包含数字键“10”并包含条目：key:2,value:“a”：

1. assertThat(map)

2.   .isNotEmpty()

3.   .containsKey(2)

4.   .doesNotContainKeys(10)

5.   .contains(entry(2, "a"));

有关更多断言，请参阅 ​​AbstractMapAssert​​ API。

完整示例：

1. @Test(description = "Map断言")

2.     public void whenGivenMap_then() {

3.         Map<Integer, String> map = Maps.newHashMap(2, "a");

4. 

5.         // 断言Map是否为空，包含key “2”，不包含key “10” 并包含元素：key:2,value:“a”

6.         assertThat(map).isNotEmpty().containsKey(2).doesNotContainKeys(10).contains(entry(2, "a"));

7.     }

Throwable 断言

Throwable 的断言允许例如：检查异常的信息，踪迹，原因检查或者异常被抛出已验证。

让我们看一下断言示例，该断言检查是否抛出了给定的异常并且消息以“c”结尾：

1. assertThat(ex).hasNoCause().hasMessageEndingWith("c");

有关更多断言，请参阅 ​​AbstractThrowableAssert​​ API。 

完整示例：

1. @Test(description = "Throwable断言")

2.     public void whenGivenException_then() {

3.         Exception ex = new Exception("abc");

4. 

5.         // 断言是否抛出了给定的异常并且消息以“c”结尾

6.         assertThat(ex).hasNoCause().hasMessageEndingWith("c");

7.     }

描述断言

为了获得更高的详细级别，你可以为断言创建动态生成的自定义描述。 这样做的关键是 as（String description，Object ... args）方法。

如果你定义这样的断言：

1. assertThat(fidos.getWeight())

2. .as("%s\'s age should be equal to 5.15f")

3. .isEqualTo(5.15f);

这是运行测试时的结果：

1. org.junit.ComparisonFailure: [%s\'s age should be equal to 5.15f] 

2. Expected :5.1[5]f

3. Actual   :5.1[4]f

完整示例：

1. @Test(description = "描述断言")

2.     public void whenRunningAssertion_thenDescribed() throws Exception {

3.         Dog fidos= new Dog("fidos",5.14f);

4. 

5.         assertThat(fidos.getWeight()).as("%s\'s age should be equal to 5.15f").isEqualTo(5.15f);

6.     }

小结

在本文中，我们简要探讨了AssertJ 为核心Java类型提供最流行的流式断言的使用方法。