使用AssertJ让单元测试和TDD更加简单

最新推荐文章于 2024-05-10 09:50:25 发布
最新推荐文章于 2024-05-10 09:50:25 发布
阅读量393 收藏
点赞数
分类专栏： java 文章标签： 单元测试 tdd junit java spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67401761/article/details/126553636
版权

文章目录

使用AssertJ让单元测试和TDD更加简单

前言

在编写单元测试时，一个重要的工作就是编写断言（Assertion），而JUnit自带的断言机制和Hamcrest的assertThat都不那么好用。

利用AssertJ，可以让单元测试更加简单，让TDD过程更加顺畅。

AssertJ的优点：

  • 通用的assertThat “流式断言”，让编写断言更加简单快捷。
  • API丰富，对各种类型的断言都非常友好。

环境

本文的测试环境：

  • JUnit4
  • assertj-core
  • Maven
  • Java8

添加assertJ的Maven依赖：

<dependency>
  <groupId>org.assertj</groupId>
  <artifactId>assertj-core</artifactId>
  <version>3.17.0</version>
  <scope>test</scope>
</dependency>

在测试类中引入AssertJ：

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

断言类型

常用的断言类型

常用的断言类型包括：

  • isSameAs： 同一个对象。
  • isEuqalsTo: 值相等。
  • isCloseTo： 值相近。
  • isTrue：为真，isFalse 为假。
  • containsExactly：包含全部元素，顺序也保持一致。
  • containsOnly：包含全部元素，顺序不需要保持一致。
  • contains：包含给定的元素。
  • hasSize：长度或大小或元素个数为N个。
  • isEmpty: 是否为空。
  • isNull：是否为null。
  • isInstanceOf：是否为指定类型。

断言的辅助方法

断言的辅助方法：

  • extracting： 提取，根据类名或方法引用或字段名反射调用，或根据lambda表达式调用。

  • mathes： 匹配，根据lambda表达式调用。

  • atIndex： 获取指定位置/索引的元素。

  • offset： 偏移量。

  • withPercentage：百分比。

  • tuple：将一组属性的值包装成元组。

  • entry：将键值对（{K,V})包装成Map.Entry。

AssertJ例子

官网：

基本类型

参见：

说明：

  • 对可以精确匹配的值（比如字符串、整数），用isEqualTo()来比较，对不能精确匹配的值（比如浮点数），用isCloseTo()比较。

  • 对布尔值，用isTrue() 或isFalse()来比较。

    @Test
    public void test_value_equals() {
    String hello = “hello”.toUpperCase();
    assertThat(hello).isEqualTo(“HELLO”);

    int secondsOfDay = 24 * 60 * 60;
    assertThat(secondsOfDay).isEqualTo(86400);
    }

    @Test
    public void test_value_close() {
    double result = 0.1 + 0.1 + 0.1; // 0.30000000000000004
    assertThat(result).isCloseTo(0.3, offset(0.0001)); // 误差值
    assertThat(result).isCloseTo(0.3, withPercentage(0.01)); // 误差百分比
    }

    @Test
    public void test_boolean() {
    boolean flag = “Kubernetes”.length() > 8;
    assertThat(flag).isTrue();

    boolean flag2 = “Docker”.length() > 8;
    assertThat(flag2).isFalse();
    }

单个对象

参见：

说明：

  • 判断是否为同一个对象用isSameAs()。

  • 如果重写了euqals和hashcode方法，也可以用isEqualTo来判断对象是否相同。

  • 如果只是判断对象的值是否相等，则可以用extracting提取后再判断，或用matches来用lambda表达式判断。

  • 判断是否为null用isNull()或isNotNull()。

    @Test
    public void test_object_null_or_not_null() {
    Person p1 = new Person(“William”, 34);
    assertThat(p1).isNotNull();

    Person p2 = null;
assertThat(p2).isNull();

    }

    @Test
    public void test_object_same_as_other() {
    Person p1 = new Person(“William”, 34);
    Person p2 = p1;
    assertThat(p1).isSameAs(p2);

    Person p3 = new Person("John", 35);
assertThat(p1).isNotSameAs(p3);

    }

    @Test
    public void test_object_equals() {
    Person p1 = new Person(“William”, 34);
    Person p2 = new Person(“William”, 34);

    assertThat(p1).isNotSameAs(p2);
assertThat(p1).isNotEqualTo(p2); // 如果用isEqualTo判断，则必须要重写equals方法

// extracting method reference
assertThat(p1).extracting(Person::getName, Person::getAge).containsExactly("William", 34);
assertThat(p1).extracting(Person::getName, Person::getAge).containsExactly(p2.getName(), p2.getAge());

// extracting field
assertThat(p1).extracting("name", "age").containsExactly("William", 34);
assertThat(p1).extracting("name", "age").containsExactly(p2.getName(), p2.getAge());

// matches
assertThat(p1).matches(x -> x.getName().equals("William") && x.getAge() == 34);
assertThat(p1).matches(x -> x.getName().equals(p2.getName()) && x.getAge() == p2.getAge());

    }

数组

参见：

说明：

  • 用isNull来判断数组是否为null。

  • 用isEmpty来判断数组是否为空（不包含任何元素）。

  • 用hasSize来判断数组的元素个数。

  • 用contains 判断数组中包含指定元素；用containsOnly判断数组中包含全部元素，但是顺序可以不一致；用cotainsExactly判断数组中包含全部元素且顺序需要一致。

  • 如果数组中的元素为对象，则需要通过extracting提取出对象的属性值，再来判断；如果提取出对象的多个属性值时，可以用tuple将多个属性值包装成元组

  • 用atIndex来获取指定位置/索引的元素

    @Test
    public void test_array_null_or_empty() {
    String[] nullNames = null;
    assertThat(nullNames).isNull();

    String[] emptyNames = {};
assertThat(emptyNames).isEmpty();
assertThat(emptyNames).hasSize(0);

    }

    @Test
    public void test_array_contains() {
    String[] names = {“Python”, “Golang”, “Docker”, “Java”};

    assertThat(names).contains("Docker");
assertThat(names).doesNotContain("Haddop");

assertThat(names).containsExactly("Python", "Golang", "Docker", "Java"); // 完全匹配，且顺序也一致
assertThat(names).contains("Java", "Docker", "Golang", "Python"); // 完全匹配，顺序可以不一致

assertThat(names).contains("Docker", atIndex(2)); // names[2]

    }

    @Test
    public void test_array_object_contains() {
    Person[] names = {new Person(“William”, 34),
    new Person(“John”, 36),
    new Person(“Tommy”, 28),
    new Person(“Lily”, 32)};

    assertThat(names).extracting(Person::getName)
  .containsExactly("William", "John", "Tommy", "Lily");

assertThat(names).extracting("name", "age")
  .containsExactly(tuple("William", 34),
                   tuple("John", 36),
                   tuple("Tommy", 28),
                   tuple("Lily", 32));

assertThat(names).extracting(x -> x.getName(), x -> x.getAge())
  .containsExactly(tuple("William", 34),
                   tuple("John", 36),
                   tuple("Tommy", 28),
                   tuple("Lily", 32));

    }

集合

List

参见：

List的断言与数组的断言类似。

@Test
public void test_list_contains() {
    List<Person> names = Arrays.asList(new Person("William", 34),
                                       new Person("John", 36),
                                       new Person("Tommy", 28),
                                       new Person("Lily", 32));

    assertThat(names).extracting(Person::getName)
      .containsExactly("William", "John", "Tommy", "Lily");

    assertThat(names).extracting("name", "age")
      .containsExactly(tuple("William", 34),
                       tuple("John", 36),
                       tuple("Tommy", 28),
                       tuple("Lily", 32));

    assertThat(names).extracting(x -> x.getName(), x -> x.getAge())
      .containsExactly(tuple("William", 34),
                       tuple("John", 36),
                       tuple("Tommy", 28),
                       tuple("Lily", 32));
  }
}
Map

参见：

说明：

  • 可以对key进行断言：

    • containsKeys：包含指定key。
    • containsOnlyKeys：包含全部key，对顺序无要求。

  • 可以对value进行断言：

    • containsValues：包含指定value。

  • 可以对entry进行断言：

    • contains：包含指定entry。
    • containsOnly：包含全部entry，对顺序无要求。

  • 注意，HashMap中的entry无序，而TreeMap中的entry有序。因此TreeMap可用containsExactly判断是否包含全部Entry，且顺序也保持一致。

    @Test
    public void test_hash_map_contains() {
    Person william = new Person(“William”, 34);
    Person john = new Person(“John”, 36);
    Person tommy = new Person(“Tommy”, 28);
    Person lily = new Person(“Lily”, 32);
    Person jimmy = new Person(“Jimmy”, 38);

    Map<String, Person> map = new HashMap<>();
map.put("A1001", william);
map.put("A1002", john);
map.put("A1003", tommy);
map.put("A1004", lily);

Map<String, Person> map2 = new HashMap<>();
map2.put("A1001", william);
map2.put("A1002", john);
map2.put("A1003", tommy);
map2.put("A1004", lily);

// contains keys
assertThat(map).containsKeys("A1003");
assertThat(map).containsOnlyKeys("A1001", "A1002", "A1003", "A1004"); // 需要包含全部的key
assertThat(map).doesNotContainKeys("B1001");

// contains values
assertThat(map).containsValues(tommy);
assertThat(map).doesNotContainValue(jimmy);

// contains entries
assertThat(map).containsEntry("A1003", tommy);
assertThat(map).containsAllEntriesOf(map2);
assertThat(map).contains(entry("A1003", tommy));
// 需要包含全部的entry
assertThat(map).containsOnly(entry("A1001", william),
                             entry("A1002", john),
                             entry("A1003", tommy),
                             entry("A1004", lily));

    }

    @Test
    public void test_tree_map_contains() {
    Person william = new Person(“William”, 34);
    Person john = new Person(“John”, 36);
    Person tommy = new Person(“Tommy”, 28);
    Person lily = new Person(“Lily”, 32);

    Map<String, Person> map = new TreeMap<>();
map.put("A1001", william);
map.put("A1002", john);
map.put("A1003", tommy);
map.put("A1004", lily);

// 需要包含全部的entry，且顺序也一致
assertThat(map).containsExactly(entry("A1001", william),
                                entry("A1002", john),
                                entry("A1003", tommy),
                                entry("A1004", lily));

    }

    @Test
    public void test_map_extracting() {
    Person william = new Person(“William”, 34);
    Person john = new Person(“John”, 36);
    Person tommy = new Person(“Tommy”, 28);
    Person lily = new Person(“Lily”, 32);

    Map<String, Person> map = new TreeMap<>();
map.put("A1001", william);
map.put("A1002", john);
map.put("A1003", tommy);
map.put("A1004", lily);

assertThat(map).extracting("A1001").isEqualTo(william);
assertThat(map).extracting("A1001")
  .extracting("name", "age")
  .containsExactly("William", 34);

    }

Set

Set的断言与List的断言类似。

异常

参见：

说明：

  • 用try catch 来捕捉可能抛出的异常。

  • 用isInstanceOf来判断异常类型。

  • 用hasMessageContaining来模糊匹配异常信息，用hasMessage来精确匹配异常信息。

  • 用hasCauseInstanceOf 来判断异常原因（root cause）的类型。

  • 对checked exception和runtime exception的断言是一样的。

    public class ExceptionExampleTest {

    public String readFirstLine(String fileName) throws IncorrectFileNameException {
    try (Scanner file = new Scanner(new File(fileName))) {
        if (file.hasNextLine()) {
            return file.nextLine();
        }
    } catch (FileNotFoundException e) {
       throw new IncorrectFileNameException("Incorrect file name: " + fileName, e);
    }
    return "";
}

/**
 * java custom exception:
 * https://www.baeldung.com/java-new-custom-exception
  */

public class IncorrectFileNameException extends Exception {
    public IncorrectFileNameException(String message) {
        super(message);
    }

    public IncorrectFileNameException(String message, Throwable cause) {
        super(message, cause);
    }
}


@Test
public void test_exception_ArithmeticException() {
    try {
        double result = 1 / 0;
    } catch(Exception e) {
        // check exception type
        assertThat(e).isInstanceOf(ArithmeticException.class);

        // check exception message
        assertThat(e).hasMessageContaining("/ by zero");
    }
}

@Test
public void test_exception_ArrayIndexOutOfBoundsException() {
    try {
        String[] names = {"William", "John", "Tommy", "Lily"};
        String name = names[4];
    } catch (Exception e) {
        // check exception type
        assertThat(e).isInstanceOf(ArrayIndexOutOfBoundsException.class);

        // check exception message
        assertThat(e).hasMessage("4");
    }
}

@Test
public void test_exception_IllegalStateException() {
    try {
        List<String> names = Arrays.asList("William", "John", "Tommy", "Lily");
        Iterator<String> iter = names.iterator();
        iter.remove();
    } catch (Exception e) {
        // check exception type
        assertThat(e).isInstanceOf(IllegalStateException.class);
    }
}


@Test
public void test_custom_exception() {
    try {
        String line = readFirstLine("./unknown.txt");
    } catch (Exception e) {
        // check exception type
        assertThat(e).isInstanceOf(IncorrectFileNameException.class);

        // check exception message
        assertThat(e).hasMessageContaining("Incorrect file name");

        // check cause type
        assertThat(e).hasCauseInstanceOf(FileNotFoundException.class);
    }
}

    }

Optional

参见：

说明：

  • 用isPresent来判断Optional是否为空。

  • 如果Optional中的值是基本类型，用hasValue判断。

  • 如果Optional中的值为对象，用hasValueSatisfying判断。

    public class OptionalExampleTest {

    @Test
public void test_optional_null_or_empty() {
    Optional<String> op1 = Optional.ofNullable(null);

    assertThat(op1).isNotPresent();
    assertThat(op1).isEmpty();

    Optional<String> op2 = Optional.empty();
    assertThat(op2).isNotPresent();
    assertThat(op2).isEmpty();
}

@Test
public void test_optional_basic_type() {
    Optional<String> op1 = Optional.ofNullable("hello");
    assertThat(op1).isPresent().hasValue("hello");

    Optional<Integer> op2 = Optional.ofNullable(365);
    assertThat(op2).isPresent().hasValue(365);
}

@Test
public void test_optional_object() {
    Optional<Person> p1 = Optional.ofNullable(new Person("William", 34));

    assertThat(p1).isPresent()
            .hasValueSatisfying(x -> {
                assertThat(x).extracting(Person::getName, Person::getAge)
                        .containsExactly("William", 34);
            });
}

    }

m0_67401761
关注
专栏目录
原创 | 使用JUnit、AssertJ和Mockito编写单元测试和实践TDD （一）什么是单元测试
编程道与术的博客
05-07 351
If builders built buildings the way programmers wrote programs, then the first woodpecker that came along would destroy civilization.（如果建筑业者用程序员写程序的方式盖楼造桥，那么第一只飞来驻足的啄木鸟就足以毁灭人类文明） ...
AssertJ 的使用
齐殿天下
08-17 176
https://assertj.github.io/doc/#assertj-core-assertion-description 官方文档 自定义断言信息 接口测试中需要在断言结果显示具体哪条用例执行报错来定位问题，特别是参数化的时候。可以用as assertThat("a").as("验证value").isEqualTo("b"); 执行结果如下： 实际使用中，参数化加个字段如comment，说明具体哪个用例，然后在 as 里把comment的值放进去即可。 ...
AssertJ 教程
neweastsun的专栏
01-16 4934
AssertJ 教程 本文学习AssertJ，一个开源的、社区驱动的测试库，可以写流畅的、丰富的Java测试断言，我们主要聚焦AssertJ-core提供的功能。 1. 概述 1.1. 依赖 首先需要增加相应依赖，Spring Boot默认已经加载。 <dependency> <groupId>org.assertj</groupId> <...
mock、junit、assertJ单元测试
Dream_it_possible！的博客
07-02 656
添加mock依赖 <!-- mock 测试--> <dependency> <groupId>org.mockito</groupId> <artifactId>mockito-core</artifactId> <version>2.23.0</version> </depen...
AssertJ使用教程（二）
qq_47993287的博客
09-16 474
AssertJ使用教程（二），介绍关于Object Assertion和String Assertion的内容
单元测试（三）AssertJ断言
weixin_43930865的博客
11-10 706
assertj官方文档 1：AssertJ介绍 AssertJ是一个Java库，它提供了一组丰富的断言和真正有用的错误消息，提高了测试代码的可读性 1.1：maven依赖 <dependency> <groupId>org.assertj</groupId> <artifactId>assertj-core</artifactId> <version>3.21.0</version>
JAVA的流畅断言库AssertJ.zip
07-17
AssertJ 是 JAVA 的流畅断言库。示例代码：// unique entry point to get access to all assertThat methods and utility methods (e.g. entry) import static org.assertj.core.api.Assertions.*;  // common assertions assertThat(frodo.getName()).isEqualTo("Frodo"); assertThat(frodo).isNotEqualTo(sauron)                  .isIn(fellowshipOfTheRing);  // String specific assertions assertThat(frodo.getName()).startsWith("Fro")                            .endsWith("do")                            .isEqualToIgnoringCase("frodo");  // collection specific assertions assertThat(fellowshipOfTheRing).hasSize(9)                                .contains(frodo, sam)                                .doesNotContain(sauron);  // using extracting magical feature to check fellowshipOfTheRing characters name :) assertThat(fellowshipOfTheRing).extracting("name").contains("Boromir", "Gandalf", "Frodo", "Legolas")                                                   .doesNotContain("Sauron", "Elrond");  // map specific assertions, ringBearers initialized with the elves rings and the one ring bearers. assertThat(ringBearers).hasSize(4)                        .contains(entry(oneRing, frodo), entry(nenya, galadriel))                        .doesNotContainEntry(oneRing, aragorn);  // and many more assertions : dates, file, numbers, exceptions ... 标签：AssertJ
assertj-core：AssertJ是一个提供易于使用的丰富类型断言的库
02-03
AssertJ-Java的流利断言 AssertJ提供了一组丰富且直观的强类型断言，用于单元测试（与JUnit，TestNG或任何其他测试框架一起使用）。 AssertJ网站包含。 （仍在旧站点中，但很快将在可用） 您可以在提出问题，并通过简单地创建问题来提出建议。 和 。 一个用于提供有关Guava类型的声明（ Multimap ， Optional ...）-请参见和 。 一个，用于为Joda Time类型（ DateTime ， LocalDateTime ）提供断言-请参见和 。 一个，用于为Neo4J类型（ Path ， Node ， Relationship ..
assertj-core-3.9.1.jar
02-26
assertj-core-3.9.1.jar包，可以在做开发的时候用 ，如果有需要可以直接进行下载 很好的一次
assertj-core-3.11.1.jar
01-08
assertj-core-3.11.1.jar
走进Java接口测试之流式断言库AssertJ
Mo小泽的技术博客
01-21 2136
文章目录前言AssertJ简介AssertJ使用导包入门使用对象断言布尔断言Iterable/Array断言字符断言类断言文件断言Double/Float/Integer断言InputStream断言Map断言Throwable 断言描述断言小结 前言 在设计自动化接口 Cases 时，遵守的核心原则是3A（Arrange-&amp;gt; Actor -&amp;gt;Assert）原则; 断言工具是否强大直接...
软件测试常见断言,断言神器AssertJ快速入门
weixin_42303616的博客
07-28 745
本帖已被设为精华帖！,1.背景在设计自动化cases时，遵守的核心原则是3A(Arrange-> Actor ->Assert)原则;断言工具是否强大直接影响到用例的执行效率，本文将介绍一种流式断言神器：AssertJ。在JAVA cases中常用的断言工具有JUnit自带的Assert，还有hamcrest的assertThat(之前总结过http://blog.csdn.net/n...
推荐使用：AssertJ - 强大的Java fluent断言库
最新发布
gitblog_00010的博客
05-10 258
推荐使用：AssertJ - 强大的Java fluent断言库 assertjAssertJ is a library providing easy to use rich typed assertions 项目地址:https://gitcode.com/gh_mirrors/as/assertj AssertJ 是一个为Java开发人员量身定制的富断言库，它提供了一套直观且类型安全的断言，...
java 断言 作用_简单了解Java断言利器AssertJ原理及用法
weixin_33181210的博客
02-16 337
AssertJ是我目前见过的最强大的断言api，没有之一。为什么使用assertJ？1、流式断言，代码即用例，直观易懂。举个例子：传统的junit或者testng，判断一个字符串包不包括a跟b两个字符。要这么写assertTrue(stringbuffer.contains("a") && stringbuffer.contains("b"))而如果你用的assertJassert...
AssertJ使用教程（一）
qq_47993287的博客
09-07 1078
AssertJ断言库的使用教程
单元测试与TDD实战指南
"本文档详细介绍了单元测试与TDD（测试驱动开发）的实践方法，包括测试目的、设计分层、DAO、Service和Action层的测试，并提供了具体的测试示例。文档强调了单元测试在保证代码质量和可维护性方面的重要性，并通过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值