Les tests unitaires que les événements sont déclenchés en C# (dans l'ordre)

Si vous êtes en train de faire TDD événement tests peuvent commencer à générer un beaucoup de code répétitif. J'ai écrit un moniteur d'événement qui permet à un beaucoup plus propre approche de test de l'unité de l'écriture de ces situations.

var publisher = new PropertyChangedEventPublisher();

Action test = () =>
{
    publisher.X = 1;
    publisher.Y = 2;
};

var expectedSequence = new[] { "X", "Y" };

EventMonitor.Assert(test, publisher, expectedSequence);

Veuillez voir ma réponse à la suite pour plus de détails.

Les tests unitaires qu'un événement est déclenché en C#, à l'aide de la réflexion

Ci-dessous est légèrement modifié André code qui, au lieu de simplement la journalisation de la séquence des événements déclenchés plutôt de compter combien de fois un événement spécifique a été appelé. Bien qu'il soit basé sur son code, je le trouve plus utile dans mes tests.

[TestMethod]
public void Test_ThatMyEventIsRaised()
{
    Dictionary<string, int> receivedEvents = new Dictionary<string, int>();
    MyClass myClass = new MyClass();

    myClass.PropertyChanged += delegate(object sender, PropertyChangedEventArgs e)
    {
        if (receivedEvents.ContainsKey(e.PropertyName))
            receivedEvents[e.PropertyName]++;
        else
            receivedEvents.Add(e.PropertyName, 1);
    };

    myClass.MyProperty = "testing";
    Assert.IsTrue(receivedEvents.ContainsKey("MyProperty"));
    Assert.AreEqual(1, receivedEvents["MyProperty"]);
    Assert.IsTrue(receivedEvents.ContainsKey("MyOtherProperty"));
    Assert.AreEqual(1, receivedEvents["MyOtherProperty"]);
}

Ne pas écrire un test pour chaque membre - c'est beaucoup de travail

(peut-être que cette solution n'est pas parfaite pour chaque situation - mais il montre une voie possible. Vous pourriez avoir besoin pour l'adapter à votre cas d'utilisation)

Il est possible d'utiliser la réflexion dans une bibliothèque afin de tester si les membres sont tous de répondre à votre propriété a changé de cas correctement:

• Événement PropertyChanged est déclenché sur setter accès
• Événement est déclenché correct (nom de la propriété est égal à l'argument soulevé de cas)

Le code suivant peut être utilisé comme une bibliothèque et montre comment tester le générique suivante classe

using System.ComponentModel;
using System.Linq;

///<summary>
///Check if every property respons to INotifyPropertyChanged with the correct property name
///</summary>
public static class NotificationTester
    {
        public static object GetPropertyValue(object src, string propName)
        {
            return src.GetType().GetProperty(propName).GetValue(src, null);
        }

        public static bool Verify<T>(T inputClass) where T : INotifyPropertyChanged
        {
            var properties = inputClass.GetType().GetProperties().Where(x => x.CanWrite);
            var index = 0;

            var matchedName = 0;
            inputClass.PropertyChanged += (o, e) =>
            {
                if (properties.ElementAt(index).Name == e.PropertyName)
                {
                    matchedName++;
                }

                index++;
            };

            foreach (var item in properties)
            { 
                //use setter of property
                item.SetValue(inputClass, GetPropertyValue(inputClass, item.Name));
            }

            return matchedName == properties.Count();
        }
    }

Les tests de votre classe peut maintenant être écrite. (peut-être que vous souhaitez diviser le test en "événement" et "événement a permis d'amasser avec le nom correct" - vous pouvez le faire vous-même)

[TestMethod]
public void EveryWriteablePropertyImplementsINotifyPropertyChangedCorrect()
{
    var viewModel = new TestMyClassWithINotifyPropertyChangedInterface();
    Assert.AreEqual(true, NotificationTester.Verify(viewModel));
}

Classe

using System.ComponentModel;

public class TestMyClassWithINotifyPropertyChangedInterface : INotifyPropertyChanged
{
        public event PropertyChangedEventHandler PropertyChanged;

        protected void NotifyPropertyChanged(string name)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(name));
            }
        }

        private int id;

        public int Id
        {
            get { return id; }
            set { id = value;
                NotifyPropertyChanged("Id");
            }
        }
}