Des événements de Test avec nunit

Je viens juste de commencer avec ATS et pourrait résoudre la plupart des problèmes que j'ai rencontrés sur mon propre. Mais maintenant je suis perdu: Comment puis-je vérifier si les événements sont déclenchés? Je cherchais quelque chose comme Assert.Raise ou Assert.Fire mais il n'y a rien. Google n'est pas très utile, la plupart des coups ont été des suggestions comme foo.myEvent += new EventHandler(bar); Assert.NotNull(foo.myEvent); mais qui ne prouve rien.

Merci!

InformationsquelleAutor atamanroman | 2010-08-02
  1. 46

    De vérifier si des événements ont déclenché peut être fait en vous inscrivant à cet événement, et de fixer une valeur booléenne:

    var wasCalled = false;
foo.NyEvent += (o,e) => wasCalled = true;

...

Assert.IsTrue(wasCalled);

    En raison de la demande - sans lambdas:

    var wasCalled = false;
foo.NyEvent += delegate(o,e){ wasCalled = true;}

...

Assert.IsTrue(wasCalled);
    • C'est très vieux... je sais... je suis curieux de savoir... est-il possible que l'assertion serait appelée avant que le code avait atteint la partie d'événement? J'ai l'impression que si le code est tellement simple que cette valeur doit être réglée avant de l'affirmer couru.
    • L'assertion pourrait être appelée avant que la valeur n'est définie que si l'événement se produit dans un autre thread. Dans ce cas, vous aurez besoin de remplacer la valeur Booléenne avec WaitHandle et attendre jusqu'à ce que c'est signalé par l'événement
    InformationsquelleAutor Dror Helper
  2. 12

    Je préfère faire comme suit:

    var wait = new AutoResetEvent(false);
foo.MeEvent += (sender, eventArgs) => { wait.Set(); };
Assert.IsTrue(wait.WaitOne(TimeSpan.FromSeconds(5)));

    Avantages: Supporte le multithreading scénario (si le gestionnaire est invoquée dans un autre thread)

    • Je vais prendre une approche similaire, mais préfèrent ManualResetEvent.
    InformationsquelleAutor aderesh
  3. 10

    Si vous connaissez l'événement sera déclenché de façon synchrone:

    bool eventRaised = false;
Customer customer = new Customer() { Name = "Carl" };
customer.NameChanged += (sender, e) => { eventRaised = true; };

customer.Name = "Sam";

Assert.IsTrue(eventRaised);

    Si l'événement peut être déclenché de manière asynchrone:

    ManualResetEvent eventRaised = new ManualResetEvent(false);
Customer customer = new Customer() { Name = "Carl" };
customer.NameChanged += (sender, e) => { eventRaised.Set(); };

customer.Name = "Sam";

Assert.IsTrue(eventRaised.WaitOne(TIMEOUT));

    Cependant, certains disent que les tests de comportement asynchrone doit être évitée.

    InformationsquelleAutor Clay
  4. 5

    J'ai récemment eu à le faire, et c'est en dessous de ce que je suis venu avec. La raison pour laquelle je ne pas faire ce que les autres postes dit, c'est que je n'aime pas l'idée d'une variable conserver l'état et d'avoir à le réinitialiser "manuellement" entre plusieurs événements.

    Ci-dessous est le code de la ClassUnderTest avec NameChanged événement qui est testé dans MyTests tests:

    public class ClassUnderTest {
private string name;
public string Name {
get { return this.name; }
set {
if (value != this.name) {
this.name = value;
NameChanged(this, new PropertyChangedEventArgs("Name"));
}
}
}
public event EventHandler<PropertyChangedEventArgs> NameChanged = delegate { };
}
[TestFixture]
public class MyTests {
[Test]
public void Test_SameValue() {
var t = new ClassUnderTest();
var e = new EventHandlerCapture<PropertyChangedEventArgs>();
t.NameChanged += e.Handler;
Event.Assert(e, Event.IsNotRaised<PropertyChangedEventArgs>(), () => t.Name = null);
t.Name = "test";
Event.Assert(e, Event.IsNotRaised<PropertyChangedEventArgs>(), () => t.Name = "test");
}
[Test]
public void Test_DifferentValue() {
var t = new ClassUnderTest();
var e = new EventHandlerCapture<PropertyChangedEventArgs>();
t.NameChanged += e.Handler;
Event.Assert(e, Event.IsPropertyChanged(t, "Name"), () => t.Name = "test");
Event.Assert(e, Event.IsPropertyChanged(t, "Name"), () => t.Name = null);
}
}

    Les classes de support sont ci-dessous. Les classes peuvent être utilisées avec n'importe quel EventHandler<TEventArgs> ou étendu à d'autres délégués. Événement tests peuvent être imbriquées.

    ///<summary>Class to capture events</summary>
public class EventHandlerCapture<TEventArgs> where TEventArgs : EventArgs {
public EventHandlerCapture() {
this.Reset();
}
public object Sender { get; private set; }
public TEventArgs EventArgs { get; private set; }
public bool WasRaised { get; private set; }
public void Reset() {
this.Sender = null;
this.EventArgs = null;
this.WasRaised = false;
}
public void Handler(object sender, TEventArgs e) {
this.WasRaised = true;
this.Sender = sender;
this.EventArgs = e;
}
}
///<summary>Contains things that make tests simple</summary>
public static class Event {
public static void Assert<TEventArgs>(EventHandlerCapture<TEventArgs> capture, Action<EventHandlerCapture<TEventArgs>> test, Action code) where TEventArgs : EventArgs {
capture.Reset();
code();
test(capture);
}
public static Action<EventHandlerCapture<TEventArgs>> IsNotRaised<TEventArgs>() where TEventArgs : EventArgs {
return (EventHandlerCapture<TEventArgs> test) => {
NUnit.Framework.Assert.That(test.WasRaised, Is.False);
};
}
public static Action<EventHandlerCapture<PropertyChangedEventArgs>> IsPropertyChanged(object sender, string name) {
return (EventHandlerCapture<PropertyChangedEventArgs> test) => {
NUnit.Framework.Assert.That(test.WasRaised, Is.True);
NUnit.Framework.Assert.That(test.Sender, Is.SameAs(sender));
NUnit.Framework.Assert.That(test.EventArgs.PropertyName, Is.EqualTo(name));
};
}
}
    InformationsquelleAutor earlNameless
  5. 1

    Pas vraiment fait cela moi-même, mais vous pourriez peut-être ajouter un mannequin gestionnaire d'événement pour l'événement que vous voulez vous abonner et de l'avoir mise à jour d'un local variable booléenne de sorte que lorsque la méthode est déclenché, vous pouvez vérifier l'état du booléen pour voir si l'événement a été déclenché?

    Quelque chose comme:

    bool eventFired = false;
foo.MyEvent += (s, e) => { eventFired = true };
Assert.IsTrue(eventFired);
    InformationsquelleAutor theburningmonk
  6. 1

    @theburningmonk: Un ";" est manquant. La version corrigée est:

    bool eventFired = false;
foo.MyEvent += (s, e) => { eventFired = true; };
Assert.IsTrue(eventFired);

    Cheers! 😉

    • bonne prise! Je mettrais à jour ma réponse mais il n'y a pas beaucoup de point que c'est vraiment une dup de Dror la réponse de toute façon
    InformationsquelleAutor Manfred
  7. 1

    À l'aide de NUnit et Moq vous pouvez faire plus robuste des cas de test.

    Classe fantaisie utilisés pour surveiller les déclencheurs d'événement:

    public class AssertEvent { public virtual void Call(string obj) { } }
Mock<AssertEvent> EventMock;
AssertEvent Evt;

    D'installation pour les Déclencheurs d'événement:

    [SetUp]
public void TestInit() {
EventMock = new Mock<AssertEvent>();
Evt= EventMock.Object;
}

    Utiliser les Objets Fantaisie dans les Tests:

    [Test]
public void TestMethod() {
myObject.Event1 += (sender, args) => Evt.Call("Event1Label");
myObject.Event2 += (sender, args) => Evt.Call("Event2Label");
myObject.Event3 += (sender, args) => Evt.Call("Event3Label");        
myObject.SomeEventTrigger();
EventMock.Verify(m => m.Call("Event1Label"), Times.Exactly(1));
EventMock.Verify(m => m.Call("Event2Label"), Times.Never());
EventMock.Verify(m => m.Call("Event3Label"), Times.Between(1,3);
}
    InformationsquelleAutor Greg
  8. 0

    Vous pouvez ajouter votre gestionnaire d'événements personnalisés qui, par exemple, par incréments de certaines champ de type entier en classe de cas de test. Et puis de vérifier si le champ a été incrémenté.

    InformationsquelleAutor DixonD