[JAVA] [MYSQL] Como fazer um teste com JUnit num C R U D?

Gostaria de saber qual a condição usar dentro do teste.

Tenho a classe Cliente

package br.myhome.web.model;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class Cliente {

	private int id;
	private String nome;
	private String telefone;
	private String email;
	
	public Cliente() {}
	
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getNome() {
		return nome;
	}
	public void setNome(String nome) {
		this.nome = nome;
	}
	public String getTelefone() {
		return telefone;
	}
	public void setTelefone(String telefone) {
		this.telefone = telefone;
	}
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}


	@Override
	public String toString() {
		return "Cliente [id=" + id + ", nome=" + nome + ", telefone=" + telefone + ", email=" + email + "]";
	}
	
	// C R U D
	
	public void cadastrar(Connection conn) {
		String sqlInserir = 
				"INSERT INTO CLIENTE (nome, telefone, email) VALUES (?, ?, ?)";
		PreparedStatement stm = null;
		try {
			stm = conn.prepareStatement(sqlInserir);
			stm.setString(1, getNome());
			stm.setString(2, getTelefone());
			stm.setString(3, getEmail());
			stm.execute();
		} catch (Exception e) {
			e.printStackTrace();
			try {
				conn.rollback();
			} catch (SQLException e1) {
				System.out.println(e1.getStackTrace());
			}
		} finally {
			if (stm!=null) {
				try {
					stm.close();
				} catch (SQLException e1) {
					System.out.println(e1.getStackTrace());
				
				} 
			}
		}
	}
	
	public void alterar (Connection conn) {
		String sqlAlterar = 
				"UPDATE CLIENTE  SET nome = ?, telefone = ?, email = ? WHERE ID = ?";
		PreparedStatement stm = null;
		try {
			stm = conn.prepareStatement(sqlAlterar);
			stm.setString(1, getNome());
			stm.setString(2, getTelefone());
			stm.setString(3, getEmail());
			stm.executeUpdate();
		} catch (Exception e1) {
			e1.printStackTrace();
		} try {
			conn.rollback();
		} catch (SQLException e1) {
			System.out.println(e1.getStackTrace());
			
		} finally {
			if (stm != null) {
				try {
					stm.close();
				} catch (SQLException e1) {
					System.out.println(e1.getStackTrace());
				}
			}
		}
	}
	
	public void excluir(Connection conn) {
		String sqlExcluir = 
				"DELETE FROM CLIENTE WHERE ID = ?";
		PreparedStatement stm = null;
		try {
			stm = conn.prepareStatement(sqlExcluir);
			stm.setInt(1, getId());
			stm.execute();
		} catch (SQLException e) {
			e.printStackTrace();
			try {
				conn.rollback();
			} catch (SQLException e1) {
				System.out.println(e1.getStackTrace());
			} 
		}	finally {
			if (stm!= null) {
				try {
					stm.close();
				} catch (SQLException e1) {
					System.out.println(e1.getStackTrace());
				}
			}
		}
	}
	
	public void carregar (Connection conn) {
		String sqlCarregar = 
				"SELECT id, nome, telefone, email WHERE ID = ?";
		PreparedStatement stm = null;
		ResultSet rs = null;
		try {
			stm = conn.prepareStatement(sqlCarregar);
			stm.setInt(1, getId());
			stm.executeQuery();
			
			if (rs.next()){
				this.setNome(rs.getString(1));
				this.setTelefone(rs.getString(2));
				this.setEmail(rs.getString(3));
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} try {
			conn.rollback();
		} catch (SQLException e1) {
			System.out.println(e1.getStackTrace());
		} finally {
			if (rs != null) {
				try {rs.close();
				} catch (SQLException e1) {
					System.out.println(e1.getStackTrace());
				}
			} if (stm != null) {
				try {
					stm.close();
				} catch (SQLException e1) {
					System.out.println(e1.getStackTrace());
				}
			}
		}
	}
}

E a classe do teste

@Test
void testCadastrar() {
	if (c.cadastrar(b.conector()))
		System.out.println("Sucesso");
	else
		System.out.println("falha");
		
}

Não se faz teste unitário com I/O envolvido. Se você quiser testar se um componente está fazendo as chamadas corretas, pode abstrair a parte de I/O com uma interface e usar mocks para testar o componente de forma isolada.