java - 应该如何设计执行 CRUD 操作的 Bean 的单元测试？

Question

我正在开发一个基于 Java EE 7 的应用程序，它使用 EJB、CDI 和 JPA 的组合来对 SQL 数据库执行创建、读取、更新和删除操作。我想为我的应用程序的服务层开发一系列单元测试，但我正在努力了解如何创建任何有意义的单元测试用例，这些用例可以增加值(value)，而不仅仅是为了代码覆盖率而进行的单元测试。我发现的大多数示例实际上都是使用内存数据库的集成测试。

应用程序的服务层是使用实体、控制和边界模式设计的。

实体是一个 JPA 带注释的 bean，包含各种 getter、setter 和命名查询，以及标准的 toString、equals 和 hashCode 方法。

Control 是一个用 @Dependent 注释的 CDI 托管 bean，包含创建、更新、删除 void 方法，这些方法调用 JPA 实体管理器持久、合并和删除方法。该控件还包含一些读取方法，这些方法使用 JPA 命名查询或 JPA 标准 API 从数据库返回 List 对象。创建、更新和删除方法执行一些基本检查，例如检查记录是否已存在，但这也是通过相关的 JPA EntityManager 方法完成的。

边界是一个用 @Stateless 注释的 EJB 托管 bean，包含最终用户可识别的方法，例如 createWidget、deleteWidget、updateWidget、activateWidget、disstopWidget、findAllWidgets 和 findASpecificWidget。对于更复杂的实体，边界将应用业务逻辑，但许多实体非常简单，不包含任何业务逻辑。 createWidget、deleteWidget、updateWidget、activateWidget、unstopWidget 方法被声明为 void，并利用异常来处理故障，例如数据库约束违规，然后将其传递到应用程序的 Web 层，以向用户呈现用户友好的消息.

我知道在编写单元测试时，我应该使用模拟框架来模拟 EntityManager 之类的东西来单独测试该方法，并且当一个方法被声明为 void 时，测试用例应该检查其状态是否已正确更改。问题是我正在努力了解大多数单元测试除了检查模拟框架是否正常工作而不是我的应用程序代码之外，还会做些什么。

我的问题是，考虑到控制组件只是调用各种 JPA EntityManager 方法并且边界组件在某些情况下不应用业务逻辑，我应该如何设计有意义的单元测试来验证边界和控制组件的正确操作？或者在这种情况下没有任何好处，相反我应该专注于编写集成测试。

更新

以下是用于维护小部件列表的服务组件的示例:

public class WidgetService {

    @PersistenceContext
    public EntityManager em;

    public void createWidget(Widget widget) {

        if (checkIfWidgetDiscontinued(widget.getWidgetCode())) {
            throw new ItemDiscontinuedException(String.format(
                    "Widget %s already exists and has been discontinued.",
                    widget.getWidgetCode()));
        }

        if (checkIfWidgetExists(widget.getWidgetCode())) {
            throw new ItemExistsException(String.format("Widget %s already exists",
                    widget.getWidgetCode()));
        }

        em.persist(widget);
        em.flush();
    }

    public void updateWidget(Widget widget) {
        em.merge(widget);
        em.flush();
    }

    public void deleteWidget(Widget widget) {
        try {
            Object ref = em.getReference(Widget.class, widget.getWidgetCode());
            em.remove(ref);
            em.flush();
        } catch (PersistenceException ex) {
            Throwable rootCause = ExceptionUtils.getRootCause(ex);
            if (rootCause instanceof SQLIntegrityConstraintViolationException) {
                throw new DatabaseConstraintViolationException(rootCause);
            } else {
                throw ex;
            }
        }
    }

    public List<Widget> findWithNamedQuery(String namedQueryName,
            Map<String, Object> parameters, int resultLimit) {
        Set<Map.Entry<String, Object>> rawParameters = parameters.entrySet();
        Query query = this.em.createNamedQuery(namedQueryName);
        if (resultLimit > 0) {
            query.setMaxResults(resultLimit);
        }
        for (Map.Entry<String, Object> entry : rawParameters) {
            query.setParameter(entry.getKey(), entry.getValue());
        }
        return query.getResultList();
    }

    public List<Widget> findWithComplexQuery(int first, int pageSize, String sortField,
            SortOrder sortOrder, Map<String, Object> filters) {

        CriteriaBuilder cb = em.getCriteriaBuilder();
        CriteriaQuery<Widget> q = cb.createQuery(Widget.class);
        Root<Widget> referenceWidget = q.from(Widget.class);
        q.select(referenceWidget);

        //Code to apply sorting and build filterCondition removed for brevity

        q.where(filterCondition);

        TypedQuery<Widget> tq = em.createQuery(q);
        if (pageSize >= 0) {
            tq.setMaxResults(pageSize);
        }
        if (first >= 0) {
            tq.setFirstResult(first);
        }

        return tq.getResultList();
    }

    public long countWithComplexQuery(Map<String, Object> filters) {

        CriteriaBuilder cb = em.getCriteriaBuilder();
        CriteriaQuery<Long> q = cb.createQuery(Long.class);
        Root<Widget> referenceWidget = q.from(Widget.class);
        q.select(cb.count(referenceWidget));

        //Code to build filterCondition removed for brevity

        q.where(filterCondition);

        TypedQuery<Long> tq = em.createQuery(q);

        return tq.getSingleResult();
    }


    private boolean checkIfWidgetExists(String widgetCode) {
        int count;
        Query query = em.createNamedQuery(Widget.COUNT_BY_WIDGET_CODE);
        query.setParameter("widgetCode", widgetCode);
        count = ((Number) query.getSingleResult()).intValue();

        if (count == 1) {
            return true;
        } else {
            return false;
        }
    }

    private boolean checkIfWidgetDiscontinued(String widgetCode) {
        int count;
        Query query = em
                .createNamedQuery(Widget.COUNT_BY_WIDGET_CODE_AND_DISCONTINUED);
        query.setParameter("widgetCode", widgetCode);
        query.setParameter("discontinued", true);
        count = ((Number) query.getSingleResult()).intValue();

        if (count == 1) {
            return true;
        } else {
            return false;
        }
    }
 }

以下是用于维护小部件列表的边界组件的示例:

@Stateless
public class WidgetBoundary {

    @Inject
    private WidgetService widgetService;

    public void createWidget(Widget widget) {
        widgetService.createWidget(widget);
    }

    public void updateWidget(Widget widget) {
        widgetService.updateWidget(widget);
    }

    public void deleteWidget(Widget widget) {
        widgetService.deleteWidget(widget);
    }

    public void activateWidget(String widgetCode) {
        Widget widget;

        widget = widgetService.findWithNamedQuery(Widget.FIND_BY_WIDGET_CODE,
                QueryParameter.with("widgetCode", widgetCode).parameters(), 0).get(0);

        widget.setDiscontinued(false);
        widgetService.updateWidget(widget);
    }

    public void discontinueWidget(Widget widget) {
        widget.setDiscontinued(true);
        widgetService.updateWidget(widget);
    }

    public List<Widget> findWithComplexQuery(int first, int pageSize, String sortField,
            SortOrder sortOrder, Map<String, Object> filters) {
        return widgetService.findWithComplexQuery(first, pageSize, sortField, sortOrder,
                filters);
    }

    public Long countWithComplexQuery(Map<String, Object> filters) {
        return widgetService.countWithComplexQuery(filters);
    }

    public List<Widget> findAvailableWidgets() {
        return widgetService.findWithNamedQuery(Widget.FIND_BY_DISCONTINUED, QueryParameter.with("discontinued", false).parameters(), 0);
    }

}

Answer 1

您的代码很难测试，因为职责没有正确分离。

WidgetBoundary 几乎不做任何事情，并将所有事情委托(delegate)给 WidgetService。

WidgetService 将业务逻辑(例如在创建小部件之前检查小部件是否已停止)与持久性逻辑(例如保存或查询小部件)混合在一起。

这使得 WidgetBoundary 完全愚蠢，并且不值得测试，而 WidgetService 则太复杂而无法轻松测试。

业务逻辑应该移至边界(我将其称为服务)。该服务(应该称为 DAO)应该只包含持久性逻辑。

这样，您就可以测试 DAO 执行的查询是否正常工作(通过使用测试数据填充数据库，调用查询方法，并查看它是否返回正确的数据)。

您还可以通过模拟 DAO 轻松快速地测试业务逻辑。这样，您不需要任何数据库来测试业务逻辑。例如，createWidget() 方法的测试可能如下所示:

@Test(expected = ItemDiscontinuedException)
public void createWidgetShouldRejectDiscontinuedWidget() {
    WidgetDao mockDao = mock(WidgetDao.class);
    WidgetService service = new WidgetService(mockDao);
    when(mockDao.countDiscontinued("someCode").thenReturn(1);

    Widget widget = new Widget("someCode");
    service.createWidget(widget);                
}