Implémentation fictive pour utilisation dans les tests automatiques d'interface utilisateur

Question

Je travaille sur l'ajout de tests d'interface utilisateur automatiques de base au bloc de tests unitaires que nous exécutons chaque génération nocturne. Nous avons utilisé l'interface utilisateur codée MSTest et créé un script. Le code-behind dépend de IClientManager qui est implémenté à la fois par le gestionnaire réel et le simulateur. Mon problème est que je ne sais pas comment basculer automatiquement entre les implémentations réelles et fictives à l'intérieur du gestionnaire de clic de bouton, lors de l'exécution d'un test. Mes deux autres contraintes sont que je ne peux pas avoir de dépendance sur le faux-assembly dans le code-behind et que je ne peux pas utiliser un framework DI, puisque le client est "conscient de la sécurité" et obtient un cadre approuvé pourrait prendre des mois.

Existe-t-il un moyen de le faire manuellement et, espérons-le, pas un problème plus important que le problème que je cherche à résoudre?

Merci!

Answer 1

Vous pouvez construire votre propre conteneur d'objet simple si vous ne pouvez pas utiliser un tiers un (ce qui est idiot, mais je comprends, je suis là avant)

ici est quelque chose que je fouetté qui pourrait ce que vous démarriez ... avez pas testé et il est vraiment difficile, mais nous espérons que vous avez l'idée

public static class ObjectFactory 
{ 
    static IDictionary<Type, object> _factory = new Dictionary<Type, object>(); 

    public static void Register<T>(Func<T> builder) 
    { 
     if (_factory.ContainsKey(typeof(T))) 
      _factory[typeof(T)] = builder; 
     else 
      _factory.Add(typeof(T), builder); 
    } 

    public static T GetInstance<T>() 
    { 
     if (_factory.ContainsKey(typeof(T))) 
      throw new ArgumentException(string.Format("Type <{0}> not registered in ObjectFactory", typeof(T).Name)); 

     return ((Func<T>)_factory[typeof(T)])(); 
    } 
} 

public interface IClientManager { } 
public class RealClientManager : IClientManager { } 
public class MockClientManager : IClientManager { } 

public class MyView 
{ 
    public MyView() 
    { 
     // probably better to do this registry in some sort of application initialization 
     ObjectFactory.Register<IClientManager>(() => new RealClientManager()); 
    } 

    public void SomeMethodThatNeedsClientManager() 
    { 
     var clientManager = ObjectFactory.GetInstance<IClientManager>(); 
    } 
} 

public class MyTester 
{ 
    [TestMethod()] 
    public void SomeTest() 
    { 
     var view = new MyView(); 

     // swap the client manager in the test 
     ObjectFactory.Register<IClientManager>(() => new MockClientManager()); 

     // Asserts 
    } 
} 

vous pouvez voir que si vous avez utilisé StructureMap ou d'un autre conteneur de DI avant de faire beaucoup de la même chose avec beaucoup de subtilités ajoutées telles que la traversée de votre graphe d'objets et l'enregistrement automatique des objets en fonction des conventions, la gestion de l'objet ecycles, délimitation des conteneurs, etc ... beaucoup de ces choses que vous pourriez vous implémenter aussi ... mais vous devriez juste vraiment utilisé une solution éprouvée telle que StructureMap