Junit Integrationstest

Question

Ich brauche Hilfe schreiben einen Komponententest für Klasse NotificationHandler. also habe ich NotificationHandlerTest (mit junit4) gemacht, aber ich weiß nicht, wie ich feststellen soll, was ich als Ergebnis im Vergleich zu dem tatsächlichen Ergebnis erwarten sollte, also würde mir ein oder mehrere einfache Tests (für einige seiner Methoden) sehr helfen!

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

Ich würde sagen, Sie mit einem einfachen Test starten, wenn Sie nicht sicher sind, was zu testen. Ein Test, der bestätigt, dass Sie keine Ausnahme erhalten, wenn Sie null als Argument senden.

z.

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

Danach können Sie Zeile für Zeile analysieren, was die Methode handle tut und Tests schreiben, die sein Verhalten überprüfen.

Sie können z. B. überprüfen, ob die Methode gateway.send(...); ausgeführt wurde oder nicht, je nachdem, was Sie im Parameter gesendet haben.

Für Abhängigkeit Mocking und Verhaltensüberprüfung, würde ich empfehlen, verwenden Sie mockito oder ein ähnliches Tool. Sie können this Tutorial folgen, um zu lernen, wie es geht.