使用 assertj 测试列表的至少一个元素是否包含特定元素

Question

假设我有球员组成了一支参加锦标赛的球队。 我想测试一下，锦标赛中至少有一支名为 T1 的球队，其中一名球员名叫保罗。

package org.example;

import java.util.List;

public class Tournament {
    List<Team> teams;
    public Tournament(){
    }

    public void create(){
        
    }

    public List<Team> getTeams() {
        return this.teams;
    }
}

package org.example;

import java.util.List;

public class Team {
    List<Player> players;
    private String name;

    public Team(String name, List<Player> players){
        this.players = players;
        this.name = name;
    }

    public List<Player> getPlayers(){
        return this.players;
    }

    public String getName() {
        return this.name;
    }
}

package org.example;

public class Player {
    String firstName;

    public Player(String firstName){
        this.firstName = firstName;
    }

    public String getFirstName(){
        return this.firstName;
    }
}

测试应如下所示：

Tournament tournament = new Tournament();
tournament.create();
assertThat(tournament)
  .hasAtLeastOneTeam()
  .withName("T1")
  .withAPlayer()
  .named("Paul")

如何使用 AssertJ 做到这一点？

Answer 1

正如 Annamalai 的回答中提到的，自定义断言将是实现您需要的 API 的方法。

但是，如果依赖现有的 AssertJ API 是一个选项，那么这里有一个可能的解决方案anySatisfy ：

assertThat(tournament.getTeams()).anySatisfy(team -> {
  assertThat(team.getName()).isEqualTo("T1");
  assertThat(team.getPlayers()).extracting(Player::getFirstName).contains("Paul");
});

Answer 2

以下课程可能会解决您的问题。

锦标赛断言

public class TournamentAssert extends AbstractAssert<TournamentAssert, Tournament> {
    public TournamentAssert(Tournament actual) {
        super(actual, TournamentAssert.class);
    }
    public static TournamentAssert assertThat(Tournament actual) {
        return new TournamentAssert(actual);
    }
    public TournamentAssert hasAtLeastOneTeam() {
        isNotNull();
        if (actual.getTeams().size() > 0) {
            failWithMessage("Expected at least one team But actual size is: <%s>", actual.getTeams().size());
        }
        return this;
    }
    public TeamAssert withName(String name) {
        isNotNull();
        for(Team team: actual.getTeams()) {
            if(name.equals(team.getName())) {
                return TeamAssert.assertThat(team);
            }
        }
        return TeamAssert.assertThat(null);
    }
}

团队声明

public class TeamAssert extends AbstractAssert<TeamAssert, Team> {
    public TeamAssert(Team actual) {
        super(actual, TeamAssert.class);
    }
    public static TeamAssert assertThat(Team actual) {
        return new TeamAssert(actual);
    }
    public PlayerAssert withAPlayer() {
        isNotNull();
        if (actual.getPlayers().size() == 1) {
            for(Player player: actual.getPlayers()) {
                return PlayerAssert.assertThat(player);
            }
        }
        return PlayerAssert.assertThat(null);
    }
}

玩家断言

public class PlayerAssert extends AbstractAssert<PlayerAssert, Player> {
    public PlayerAssert(Player actual) {
        super(actual, PlayerAssert.class);
    }
    public static PlayerAssert assertThat(Player actual) {
        return new PlayerAssert(actual);
    }
    public PlayerAssert named(String name) {
        isNotNull();
        if (!name.equals(actual.getFirstName())) {
            failWithMessage("Expected a player name is: <%s> But actual name is <%s>",name,  actual.getFirstName());
        }
        return this;
    }
}

如果需要，您还可以在TournamentAssert中使用单个 function 进行断言：

public TeamAssert withNameAndAPlayerAndNamed(String name, String playerName) {
            isNotNull();
            for(Team team: actual.getTeams()) {
                if(name.equals(team.getName())) {
                    if (team.getPlayers().size() == 1) {
                        for(Player player: team.getPlayers()) {
                            if (!playerName.equals(player.getFirstName())) {
                                failWithMessage("Expected a player name is: <%s> But actual name is <%s>",name,  player.getFirstName());
                            }
                        }
                    }
                }
            }
            return this;
        }