如何使用 Mockito 测试 DAO 方法？

Question

我已经开始发现 Mockito 库，并且有一个问题我没有找到正确的答案。

例如，如果我的 UserDAO 类中有这样的方法，可以将用户保存在数据库中：

public class UserDAO{
...
 public void create(User user) {
        Connection connection = null;
        PreparedStatement pstmt = null;
        ResultSet generatedKeys = null;
        try {

            connection = getConnection();
            pstmt = connection.prepareStatement(INSERT_USER,
                    PreparedStatement.RETURN_GENERATED_KEYS);
            int counter = 1;
            pstmt.setString(counter++, user.getFirstName());
            pstmt.setString(counter++, user.getLastName());
            pstmt.setString(counter++, user.getEmail());
            pstmt.setString(counter++, user.getPassword());
            pstmt.setString(counter++, user.getRole());
            pstmt.setString(counter, user.getLang());

            pstmt.execute();
            connection.commit();
            generatedKeys = pstmt.getGeneratedKeys();

            if (generatedKeys.next()) {
                user.setId(generatedKeys.getInt(Fields.GENERATED_KEY));
            }
        } catch (SQLException e) {
            rollback(connection);
            LOG.error("Can not create a user", e);
        } finally {
            close(connection);
            close(pstmt);
            close(generatedKeys);
        }
    }
  ....
}

我应该如何测试它？

如果我想测试一个 DAO 类，那么我需要创建一个DataSource mock、 Connection mock、 ResultSet mock 等吗？ 所以不测试数据库本身？

但是如果我还想测试 dao 和 database 的行为呢？

您能否提供一些代码示例、可能有用的链接并展示最佳方法？

Answer 1

这是使用 Mockito 测试 UserDAO 的良好开端。 此代码使用了大量的 Mockito 功能，因此您可以了解如何使用它们。 如果您有任何问题，请告诉我。

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import javax.sql.DataSource;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.*;
import org.junit.runner.RunWith;
import static org.mockito.Matchers.anyInt;
import static org.mockito.Matchers.anyString;
import org.mockito.Mock;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import org.mockito.runners.MockitoJUnitRunner;

@RunWith(MockitoJUnitRunner.class)
public class TestUserDAO {

    @Mock
    DataSource mockDataSource;
    @Mock
    Connection mockConn;
    @Mock
    PreparedStatement mockPreparedStmnt;
    @Mock
    ResultSet mockResultSet;
    int userId = 100;

    public TestUserDAO() {
    }

    @BeforeClass
    public static void setUpClass() throws Exception {
    }

    @AfterClass
    public static void tearDownClass() {
    }

    @Before
    public void setUp() throws SQLException {
        when(mockDataSource.getConnection()).thenReturn(mockConn);
        when(mockDataSource.getConnection(anyString(), anyString())).thenReturn(mockConn);
        doNothing().when(mockConn).commit();
        when(mockConn.prepareStatement(anyString(), anyInt())).thenReturn(mockPreparedStmnt);
        doNothing().when(mockPreparedStmnt).setString(anyInt(), anyString());
        when(mockPreparedStmnt.execute()).thenReturn(Boolean.TRUE);
        when(mockPreparedStmnt.getGeneratedKeys()).thenReturn(mockResultSet);
        when(mockResultSet.next()).thenReturn(Boolean.TRUE, Boolean.FALSE);
        when(mockResultSet.getInt(Fields.GENERATED_KEYS)).thenReturn(userId);
    }

    @After
    public void tearDown() {
    }

    @Test
    public void testCreateWithNoExceptions() throws SQLException {

        UserDAO instance = new UserDAO(mockDataSource);
        instance.create(new User());

        //verify and assert
        verify(mockConn, times(1)).prepareStatement(anyString(), anyInt());
        verify(mockPreparedStmnt, times(6)).setString(anyInt(), anyString());
        verify(mockPreparedStmnt, times(1)).execute();
        verify(mockConn, times(1)).commit();
        verify(mockResultSet, times(2)).next();
        verify(mockResultSet, times(1)).getInt(Fields.GENERATED_KEYS);
    }

    @Test(expected = SQLException.class)
    public void testCreateWithPreparedStmntException() throws SQLException {

         //mock
         when(mockConn.prepareStatement(anyString(), anyInt())).thenThrow(new SQLException());


        try {
            UserDAO instance = new UserDAO(mockDataSource);
            instance.create(new User());
        } catch (SQLException se) {
            //verify and assert
            verify(mockConn, times(1)).prepareStatement(anyString(), anyInt());
            verify(mockPreparedStmnt, times(0)).setString(anyInt(), anyString());
            verify(mockPreparedStmnt, times(0)).execute();
            verify(mockConn, times(0)).commit();
            verify(mockResultSet, times(0)).next();
            verify(mockResultSet, times(0)).getInt(Fields.GENERATED_KEYS);
            throw se;
        }

    }
}

Answer 2

但是如果我还想测试 dao 和 database 的行为呢？

如果您确实想测试数据库（正如您应该做的那样！），没有办法解决它 - 您需要一个实际的数据库。 Mockito 虽然是一个很棒的库，但可能是这项工作的错误工具。

Answer 3

以下是您应该如何测试它：

public class UserDAOTest extends IntegrationTests
{
    // Or do it in a @Before method, if needed.
    UserDAO dao = new UserDAO();

    @Test
    public void createValidUser() {
        User validUser = new User(
            "John", "Smith", "johns@gmail.com", "Abc123!@",
            "admin", "en"); // or use setters as needed

        dao.create(validUser);

        assertEntityCreatedInDB(validUser);
    }

    @Test
    public void attemptToCreateInvalidUser() {
        User invalidUser = new User("", null, null, "", null, "XY");

        dao.create(invalidUser);

        // This really shouldn't be done this way, as DAOs are not supposed
        // to manage transactions; instead, a suitable, descriptive
        // exception should be thrown by the DAO and checked in the test.
        assertTransactionWasRolledBack();
    }
}

关于上述内容的几点说明：

1) 测试看起来简短、简单、易于理解，应该是这样； 如果它们看起来像另一个答案中的那些又大又丑，那么你做的事情根本上是错误的。

2) 测试代码可以而且应该有自己的基础设施助手，例如IntegrationTests基类，它将隐藏任何对实际测试的讨厌的 JDBC/ORM 访问。 我在几个项目中实现了这样的助手，所以我知道这是可以做到的，但这将是其他问题的东西。

Answer 4

像DBUnit和 JUnit 这样的工具可以帮助您使用数据库测试您的 DAO。 DBUnit 帮助您在 UnitTest 之前将测试数据插入数据库，并在测试之后将数据库中的数据与您的期望进行比较。

Answer 5

这是我的测验应用程序中的一个示例

    @Test
fun quizDao() {
    val database = mockk<AppDatabase>()
    val dao = mockk<QuizDao>()
    val application = mockk<Application>()
    val appModule = mockk<AppModule>()
//quiz
    val quiz1 = Quiz("Joe","Best Quize","people Around the World","General",23)
//Questions
    val questions1 : Questions = Questions(1,"What's your group", "G1","G2","G3","G4","G1")


    every { dao.getQuizQuestions(23) } returns listOf(questions1)

    assertEquals(listOf(questions1),dao.getQuizQuestions(23))

}

}