Médiateur de tests unitaires et voir dans robotlegs 2

Question

J'apprends le framework robotlegs, mais cette question est aussi celle de la nature générale.

J'ai une classe Mediator qui écoute un événement sur un bouton dans View et à cet événement, elle distribue un signal contenant VO qui contient les propriétés de deux objets TextField dans View.

Ci-dessous la classe des médiateurs. Le bouton

est une variable privée qui n'a que getter et aucun paramètre dans View.

Ma question est, comment pourrais-je tester cette classe? 1. pour vérifier si l'événement est que le signal est envoyé ... 2. lorsque le signal est envoyé, qu'il contient correct VO

Je sais que je dois utiliser Mock, et je me sers mockolate, mais je Je tourne en cercle, parce que je ne sais pas comment se moquer d'un événement distribué d'un bouton de la classe de vue?

Merci pour l'aide

 public class LoginFormMediator extends Mediator { 

      //--------------------------------------------------------------- 
      // Public variables 
      //--------------------------------------------------------------- 



      [Inject] 
      public var view:LoginFormView; 
      [Inject] 
      public var authorizationSignal:AuthorizationSignal; 


      //--------------------------------------------------------------- 
      // Public Functions 
      //--------------------------------------------------------------- 

      override public function initialize():void 
      { 
       view.button.addEventListener(MouseEvent.CLICK,onLogin,false,0,true); 

      } 



      //--------------------------------------------------------------- 
      // Private methods 
      //--------------------------------------------------------------- 
      private function onLogin(event:MouseEvent):void { 
       var userInfo:UserInfo = new UserInfo(view.usernameField.text,view.passwordField.text); 
       authorizationSignal.dispatch(userInfo); 

      } 

     } 
     } 

Answer 1

Il y a quelques possibilités:

1/ne pas exposer le bouton et de laisser le médiateur écouter directement. La vue devrait envoyer un événement spécifique et concret auquel le médiateur écoute et, de préférence, décrire l'intention de l'utilisateur, et non l'action de l'utilisateur. E.g: laissez la vue envoyer un LoginFormViewEvent.LOGIN_REQUESTED ou peut-être un événement LoginFormViewEvent.CREDENTIALS_PROVIDED. La raison pour laquelle cela est meilleur est qu'elle ne lie pas votre médiateur à une implémentation spécifique de votre vue. Par exemple, peut-être plus tard, vous voulez ajouter une sorte de règle de validation qui doit être exécutée avant que les informations d'identification soient distribuées. Si vous écoutez le bouton directement, vous allez soit écrire la logique de validation dans le médiateur, ce qui est un non-non certain ou vous devrez refactoriser votre point de vue.

Un travail de médiateurs est de servir de médiateur entre une vue et le système, rien de plus. Il n'a pas besoin de savoir quels éléments de l'interface utilisateur sont dans la vue, il suffit de transmettre les données de la vue au système et vice versa. 2/Une autre possibilité consiste à laisser le médiateur faire passer le signal à l'échelle du système à la vue, ce qui correspond à la population expéditrice et VO. J'ai tendance à rendre le signal instancié de manière conditionnelle et générique, pour rendre la vue plus facilement réutilisable. Comme ceci:

//view 
private var _authorizationSignal : ISignal; 
public function set authorizationSignal(value : ISignal) : void{ 
    _authorizationSignal = value; 
} 
public function get authorizationSignal() : ISignal{ 
    return _authorizationSignal ||= new Signal(); 
} 

Ensuite, l'injection de signal est facultative et la vue fournit une instance de signal par défaut. 3/Ou si vous choisissez de vous en tenir à votre approche d'origine, vous pouvez vous moquer du bouton de la manière habituelle. Laissez votre vue implémenter une interface où un getter pour le bouton est déclaré. Mappez votre médiateur à l'interface (ce qui est une bonne pratique de toute façon) au lieu du type de vue concret. De cette façon, vous pouvez lui assigner un bouton mocké dans la classe de test, mais le bouton est encapsulé face au médiateur.

Ensuite, pour avoir l'envoi de bouton moquée l'événement:

[Mock] 
public var mockButton : Button; 

//in setup 
view.button = mockButton 

//in test 
mockButton.dispatch(new MouseEvent(MouseEvent.CLICK));