java - español - patrones jdbc dao

Unidad probando una clase DAO que usa Spring JDBC

Question

Tengo varios objetos DAO que se utilizan para recuperar información de una base de datos y realmente quiero escribir algunas pruebas automáticas para ellos, pero me cuesta mucho encontrar la manera de hacerlo.

Estoy usando Spring''s JdbcTemplate para ejecutar la consulta real (a través de una declaración preparada) y asignar los resultados al objeto modelo (a través de la clase RowMapper ).

Si tuviera que escribir pruebas unitarias, no estoy seguro de cómo debería / debería burlarme de los objetos. Por ejemplo, dado que solo hay lecturas, usaría la conexión de la base de datos real y no me burlaría de jdbcTemplate, pero no estoy seguro de que sea correcto.

Aquí está el código (simplificado) para el DAO más simple del lote:

/**
 * Implementation of the {@link BusinessSegmentDAO} interface using JDBC.
 */
public class GPLBusinessSegmentDAO implements BusinessSegmentDAO {
    private JdbcTemplate jdbcTemplate;

    private static class BusinessSegmentRowMapper implements RowMapper<BusinessSegment>  {
        public BusinessSegment mapRow(ResultSet rs, int arg1) throws SQLException { 
            try {
                return new BusinessSegment(rs.getString(...));
            } catch (SQLException e) {
                return null;
            }
        }
    }

    private static class GetBusinessSegmentsPreparedStatementCreator 
        implements PreparedStatementCreator {
        private String region, cc, ll;
        private int regionId;

        private GetBusinessSegmentsPreparedStatementCreator(String cc, String ll) {
            this.cc = cc;
            this.ll = ll;
        }

        public PreparedStatement createPreparedStatement(Connection connection)
                throws SQLException {           
            String sql = "SELECT ...";

            PreparedStatement ps = connection.prepareStatement(sql);
            ps.setString(1, cc);
            ps.setString(2, ll);
            return ps;
        }
    }

    public GPLBusinessSegmentDAO(DataSource dataSource) {
        jdbcTemplate = new JdbcTemplate(dataSource);
    }

    public Collection<BusinessSegment> getBusinessSegments(String cc, String ll) {
        return jdbcTemplate.query(
                new GetBusinessSegmentsPreparedStatementCreator(cc, ll), 
                new BusinessSegmentRowMapper());
    }

}

Cualquier idea sera apreciada.

¡Gracias!

Answer 1

Para escribir una prueba unitaria verdadera para esto, no estaría tocando una base de datos real. Sin embargo, puede resultar más práctico pasar un DataSource real a su base de datos subyacente, y probar el método getBusinessSegments () devuelve 0, 1 y muchos resultados dependiendo de los valores de cc y ll que pase.

Otra opción que vale la pena investigar es pasar un DataSource de un Java DB incrustado que se inicializó con su esquema en un método setUp / @ Before. Supongo que lo que realmente quiere probar es que la consulta SELECCIONAR ... se correlacione correctamente con el esquema, por lo que una prueba así detectaría cualquier error que surja en el tiempo de ejecución cuando cambie el esquema, por ejemplo.

Answer 2

Por favor, eche un vistazo a los enlaces a continuación:

1. Prueba de consultas SQL con Spring y DbUnit
2. MockObjects o DBUnit para probar el código usando JdbcTemplate

Espero que ayude.

EDITAR:

Aquí está la versión de GitHub de RowMapperTests para una fácil referencia.

Answer 3

Recomiendo romper su dependencia en la clase JdbcTemplate , y usar la interfaz JdbcOperations , por ejemplo,

public class GPLBusinessSegmentDAO implements BusinessSegmentDAO {
    private final JdbcOperations jdbc;

    public GPLBusinessSegmentDAO(DataSource dataSource) {
        this(new JdbcTemplate(dataSource));
    }

    public GPLBusinessSegmentDAO(JdbcOperations jdbc) {
        this.jdbc = jdbc;
    }

    // ... DAO methods here
}

La prueba de su unidad puede invocar al segundo constructor, pasando un objeto JdbcOperations simulado. Dado que todas las operaciones DB se realizan a través del objeto jdbc , puede simular eso con la suficiente facilidad.

Tu código en vivo puede llamar al primer constructor como antes.