Test des présentateurs dans l'application MVP GWT

Question

J'ai une application simple et je veux la rendre testable. Je suis nouveau dans ce domaine. Voici un présentateur simple, en tenant compte de ce code, pourriez-vous donner des conseils ou me donner un exemple de comment le tester.

public class SomePresenter extends Presenter<MainPanelPresenter.Display> 
    { 

    public interface Display extends WidgetDisplay 
    { 
     HasClickHandlers getAddButton(); 

     HasClickHandlers getDeleteButton(); 

     void setData(ArrayList<Person> data); 

     ArrayList<String> getSelectedRows(); 

     Widget asWidget(); 

    } 

    private final DispatchAsync dispatcher; 
    public static final Place PLACE = new Place("main"); 

    @Inject 
    public SomePresenter(DispatchAsync dispatcher, EventBus eventBus, Display display) 
    { 
     super(display, eventBus); 
     this.dispatcher = dispatcher; 
     bind(); 
    } 

    protected void onBind() 
    { 
     display.getAddButton().addClickHandler(new ClickHandler() 
     { 
     public void onClick(ClickEvent event) 
     { 
      eventBus.fireEvent(new AddButtonEvent()); 
     } 
     }); 

     display.getDeleteButton().addClickHandler(new ClickHandler() 
     { 
     public void onClick(ClickEvent event) 
     { 
      ArrayList<String> list = display.getSelectedRows(); 
      deletePerson(list); 
     } 
     }); 
    } 
    .... 
    private void loadDbData() 
    { 
    .......... 
    } 
    private void deletePerson(ArrayList<String> ids) 
    { 
    .......... 
    } 
    } 

Edit:

Qu'est-ce que le présentateur, charger des données initiales de db, ont 2 boutons ajouter et supprimer. Lorsque l'ajout est appuyez sur puis un nouveau formulaire est charger et l'utilisateur est en mesure d'entrer des données et enregistrer dans le db, supprimer le bouton simplement supprimer la personne de DB.

Merci

Answer 1

L'idée générale des tests unitaires d'une telle classe serait, comme pour toute autre classe:

• Créer une version Mock des dépendances (affichage, EventBus, etc ...)
• attentes fixés sur ce que les depdencies devraient faire quand le présentateur travaille
• le présentateur et exercice vérifier les attentes

Cependant, il y a quelques problèmes avec votre version du présentateur:

• La méthode loadDbData() n'est pas montré, mais je suppose que cela signifie le présentateur a également accès à un autre composant qui fait le fetching . Ce composant peut-il être supprimé dans une dépendance, et moqué aimait le reste?

• Puis il y a le test de bind(). La seule responsabilité de votre présentateur dans cette méthode consiste à configurer des rappels sur certains boutons fournis par l'affichage. Ce que vous voulez tester est à la fois:

  • Que les callbacks sont mis
  • Que les callbacks font les choses attendues

Quelques idées pour aider à la plus tardive:

Vous pouvez réduire le couplage entre Presenter et Button.Si possible, changer l'interface d'affichage de:

Button getAddButton(); 

à

addAddButtonClickedHandler(ClickHandler); 

Cela signifie que votre présentateur ne doit pas utiliser un objet d'affichage qui retourne BUTTON réelle

Vous pouvez réduire la teneur en callbacks pour appeler une seule méthode, que vous pouvez ensuite tester en isolation

protected void bind() { 
    display.addAddButtonClickHandler(new ClickHandler() { 
     public void onClick(ClickEvent) { 
      fireAdded(); 
     } 
    }); 
} 

// The fireAdded function can be tested independenty of the Display, potentially with 
// a mock EventBus 
protected void fireAdded() { 
    event.fireEvent(....) 
} 

Si vous voulez vraiment vérifier que les callbacks sont correctement réglés, que vous pouvez utiliser une implémentation « factice » de la classe d'affichage, qui vous fournit une liste de tous les callbacks, et laissez-vous les appelez

private class DummyDisplay implements Display { 

    private List<ClickHandler> addButtonClickHandlers; 
    public void addAddButtonClickHandler(ClickHandler handler) { 
     addButtonClickHandlers.add(handler); 
    } 
    public void fireAddButtonClick() { 
     for (ClickHandler h in addButtonClickHandlers) { 
       h.onClick(new ClickEvent()); 
     } 
    } 
    // .... 
} 

ensuite, votre test serait:

• créer un présentateur avec un tel écran factice
• utilisation se lient à définir les callbacks
• utilisation display.fireAddButtonClick() pour simuler un utilisateur en cliquant sur
• contrôle qui a le résultat du clic, les effets de fireAdded sont vus

Ce type de classe (qui colle la plupart du temps d'autres classes ensemble) peuvent avoir tendance à être difficiles à tester; à un certain point, si les autres classes sont soigneusement testées, elles peuvent devenir légèrement contre-productives pour se concentrer sur les colleuses plutôt que sur les collées.

En espérant que cela aide.