Java Junit集成测试

我需要帮助为类NotificationHandler编写单元测试。因此，我使用junit4进行了NotificationHandlerTest，但我不知道如何确定预期的结果和实际结果，因此对某些方法进行一个或多个简单的测试会对我有很大帮助

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);
        }
    }

---

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

例如

之后，您可以逐行分析方法句柄正在执行的操作，并编写验证其行为的测试

例如，您可以验证方法gateway.send。。。；是否执行取决于您在参数中发送的内容

对于依赖项模拟和行为验证，我建议您使用mockito或类似的工具。

---

您可以按照教程学习如何操作。

您确实需要知道您正在测试的类的功能以及其方法的预期行为。欢迎使用SO。请展示您迄今为止所做的尝试，并提出具体的问题，以便我们能给您具体的答案！

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