Junit集成测试

Question

我需要帮助为类NotificationHandler编写单元测试。所以我做了NotificationHandlerTest (使用junit4)，但是我不知道如何确定我应该期望的结果和实际的结果，所以一个或多个简单的测试(对于它的一些方法)会对我有很大的帮助！

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.integration.annotation.Poller;
import org.springframework.integration.annotation.ServiceActivator;
import org.springframework.messaging.Message;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.stream.Collectors;

@Component
class NotificationHandler {

    private static Logger LOG = LoggerFactory.getLogger(NotificationHandler.class);

    @Autowired
    private NotificationRoutingRepository routingRepository;

    @Autowired
    private SendNotificationGateway gateway;

    @Autowired
    private AccessService accessService;

    @Autowired
    private EndpointService endpointService;

    @ServiceActivator(inputChannel = Channels.ASSET_MODIFIED_CHANNEL, poller = @Poller("assetModifiedPoller"), outputChannel = Channels.NULL_CHANNEL)
    public Message<?> handle(Message<EventMessage> message) {
        final EventMessage event = message.getPayload();

        LOG.debug("Generate notification messages: {}, {}", event.getOriginType(), event.getType());

        routingRepository.findByOriginTypeAndEventType(event.getOriginType(), event.getType()).stream()
                .filter(routing -> routing.getOriginId() == null || routing.getOriginId() == event.getOriginId())
                .map(routing -> getNotificationMessages(event, routing))
                .flatMap(List::stream)
                .forEach(notificationMessage -> {
                    LOG.debug("Sending message {}", notificationMessage);
                    gateway.send(notificationMessage);
                });

        return message;
    }enter code here
    enter code here`enter code here`
    private List<NotificationMessage> getNotificationMessages(EventMessage event, NotificationRouting routing) {
        switch (routing.getDestinationType()) {
            case "USERS":
                LOG.trace("Getting endpoints for users");
                return getEndpointsByUsers(routing, event.getOrigin(), event.getOriginType()).stream()
                        .map(endpoint -> new NotificationMessage(event.getOriginType(), event.getOrigin(), endpoint))
                        .collect(Collectors.toList());
            default:
                LOG.trace("Getting default endpoints");
                return getEndpoints(routing, event.getOrigin(), event.getOriginType()).stream()
                        .map(endpoint -> new NotificationMessage(event.getOriginType(), event.getOrigin(), endpoint))
                        .collect(Collectors.toList());
        }
    }

    private List<Endpoint> getEndpoints(NotificationRouting routing, Object origin, String originType) {
        final Asset asset = getAssetForObject(origin, originType);

        final List<Long> userIds = accessService.list(asset).stream()
                .map(ResourceAccess::getUser)
                .map(AbstractEntity::getId)
                .collect(Collectors.toList());

        userIds.add(asset.getCreatorId());

        LOG.trace("getEndpoints usersIds {}", userIds);

        final List<Endpoint> endpoints = endpointService.getEndpoints(userIds, routing.getEndpointType());
        LOG.trace("Endpoints {}", endpoints.stream().map(Endpoint::getId).collect(Collectors.toList()));
        return endpoints;
    }

    private List<Endpoint> getEndpointsByUsers(NotificationRouting routing, Object origin, String originType) {
        final Asset asset = getAssetForObject(origin, originType);

        final List<Long> userIds = accessService.list(asset).stream()
                .map(ResourceAccess::getUser)
                .map(AbstractEntity::getId)
                .filter(routing.getDestinations()::contains)
                .collect(Collectors.toList());

        routing.setDestinations(userIds);
        routingRepository.save(routing);

        LOG.trace("getEndpointsByUsers usersIds {}", userIds);

        final List<Endpoint> endpoints = endpointService.getEndpoints(userIds, routing.getEndpointType());
        LOG.trace("Endpoints {}", endpoints.stream().map(Endpoint::getId).collect(Collectors.toList()));
        return endpoints;
    }

    private Asset getAssetForObject(Object origin, String originType) {
        switch (originType) {
            case EventMessage.POINT:
                return (Point) origin;
            case EventMessage.FEED:
                return ((Feed) origin).getPoint();
            case EventMessage.ACTUATOR:
                return ((Actuator)origin).getPoint();
            case EventMessage.DEVICE:
                return (Device) origin;
            case EventMessage.ALARM:
                return ((Alarm) origin).getPoint();
            default:
                throw new IllegalArgumentException("Unsupported type: " + originType);
        }
    }

}

Answer 1

如果你不确定要测试什么，我建议你从一个简单的测试开始。如果您将null作为参数发送，一个测试将验证您不会得到任何异常。

例如。

@Test
public void shouldNotThrowAnyExceptionIfArgumentIsNull() {
  // given
  NotificationHandler handler = new NotificationHandler();
  // when
  handler.handle(null);
  // then no exception is thrown.
}

在此之后，您可以逐行分析方法handle正在做什么，并编写验证其行为的测试。

例如，您可以根据您在参数中发送的内容来验证是否执行了方法gateway.send(...);。

对于依赖项模拟和行为验证，我建议您使用mockito或类似的工具。你可以按照this教程学习如何做到这一点。