unité de test d'une classe d'événements et délégué

Je suis nouveau à l'essai s'il vous plaît aider.

J'ai la classe suivante

public delegate void OnInvalidEntryMethod(ITnEntry entry, string message);

public class EntryValidator
{
    public event OnInvalidEntryMethod OnInvalidEntry;

    public bool IsValidEntry(ITnEntry entry, string ticker)
    {
        if (!IsFieldValid(entry, ticker.Trim().Length.ToString(), "0"))
            return false;

        return true;
    }

    private bool IsFieldValid(ITnEntry entry, string actual, string invalidValue)
    {
        if (actual == invalidValue)
        {
            RaiseInvalidEntryEvent(entry);
            return false;
        }

        return true;
    }

    private void RaiseInvalidEntryEvent(ITnEntry entry)
    {
        if (OnInvalidEntry != null)
            OnInvalidEntry(entry, "Invalid entry in list: " + entry.List.Name + ".");
    }
}

J'ai écrit le scénario de test, jusqu'à présent, mais je suis aux prises avec l'événement et délégué comme indiqué ci-dessous

[TestFixture]
public class EntryValidatorTests
{
    private EntryValidator _entryValidator;

    private FakeTnEntry _selectedEntry;
    private string _ticker;

    [SetUp]
    public void Setup()
    {
        _entryValidator = new EntryValidator();
        _ticker = "BOL";
    }

    private FakeTnEntry MakeEntry(string ticker)
    {
        return new FakeTnEntry { Ticker = ticker};
    }

    [Test]
    public void IsValidEntry_WithValidValues()
    {
        _selectedEntry = MakeEntry(_ticker);

        Assert.IsTrue(_entryValidator.IsValidEntry(_selectedEntry, _selectedEntry.Ticker));
    }

    [Test]
    public void IsValidEntry_WithInValidTicker()
    {
        _selectedEntry = MakeEntry("");
        Assert.IsFalse(_entryValidator.IsValidEntry(_selectedEntry, _selectedEntry.Ticker));
    }
}}

Svp quelqu'un peut-il aider? Merci..

OriginalL'auteur user175084 | 2013-05-08

c#delegates events nunit unit-testing

11

Le plus simple est probablement juste de vous inscrire à l'événement à l'aide d'une méthode anonyme:
```
[Test]
public void IsValidEntry_WithValidValues()
{
    _selectedEntry = MakeEntry(_ticker);
    _entryValidator.OnInvalidEntry += delegate { 
        Assert.Fail("Shouldn't be called");
    };

    Assert.IsTrue(_entryValidator.IsValidEntry(_selectedEntry, _selectedEntry.Ticker));
}    

[Test]
public void IsValidEntry_WithInValidTicker()
{
    bool eventRaised = false;
    _selectedEntry = MakeEntry("");
    _entryValidator.OnInvalidEntry += delegate { eventRaised = true; };

    Assert.IsFalse(_entryValidator.IsValidEntry(_selectedEntry, _selectedEntry.Ticker));
    Assert.IsTrue(eventRaised);
}
```
Dans le deuxième test, vous pourriez vouloir valider que les arguments de l'événement ont été comme prévu.

Notez également que "non valide" est un mot - de sorte que votre essai doit être IsValidEntry_WithInvalidTicker. Je voudrais aussi de ne pas s'embêter avec la configuration que je venais de déclarer de nouvelles variables locales dans chaque test.

Merci beaucoup monsieur pour la réponse rapide.. je ne parviens pas besoin d'une propriété ou d'un événement pour OnInvalidEntry?
Vous avez déjà eu l'événement dans EntryValidator. Vous êtes juste abonnement pour l'événement à l'aide d'une méthode anonyme.
parfait merci// est-il un article ou d'échantillons ou de tout type de matériel que je peux lire plus à ce sujet?
Qui bits? Les méthodes anonymes? Êtes-vous familier avec les expressions lambda?
De bons articles/tutoriels sur les essais et non je ne suis pas trop familier avec les expressions lambda, mais connaissez un peu à ce sujet.

OriginalL'auteur Jon Skeet

Je restructurer votre classe pour faire de la RaiseInvalidEntryEvent virtuel de sorte qu'il peut être une fantaisie dans votre IsValidEntry_WithInValidTicker et ensuite vérifié qu'il a été appelée lorsque le billet n'était pas valide.

Alors j'aurais un autre test qui vérifie RaiseInvalidEntryEvent appelé le anon délégué séparément.

Les tests unitaires doivent être atomiques que possible, et vous voulez vérifier à la fois de ces comportements dans les différents tests.

public delegate void OnInvalidEntryMethod(ITnEntry entry, string message);
public class EntryValidator
{
public event OnInvalidEntryMethod OnInvalidEntry;
public bool IsValidEntry(ITnEntry entry, string ticker)
{
if (!IsFieldValid(entry, ticker.Trim().Length.ToString(), "0"))
return false;
return true;
}
private bool IsFieldValid(ITnEntry entry, string actual, string invalidValue)
{
if (actual == invalidValue)
{
RaiseInvalidEntryEvent(entry);
return false;
}
return true;
}
public virtual void RaiseInvalidEntryEvent(ITnEntry entry)
{
if (OnInvalidEntry != null)
OnInvalidEntry(entry, "Invalid entry in list: " + entry.List.Name + ".");
}
}
//Had to reverse engineer the following since they were not available in the question
public interface ITnEntry
{
Ticket List { get; set; }
string Ticker { get; set; }
}
public class TnEntry : ITnEntry
{
public Ticket List { get; set; }
public string Ticker { get; set; }
}
public class Ticket
{
public string Name { get; set; }
}

REMARQUE: Certains OOP evangalists avoir des crises quand les choses sont déclarées public plutôt que privé, essentiellement les tests unitaires et TDD avoir des exigences pur de la programmation orientée objet est à l'opposé. J'ai fait RaiseInvalidEntryEvent public pour des raisons de simplicité, mais normalement, je devrais faire ce interne et d'exposer à l'assemblée de l'unité de test via InternalsVisibleTo. J'ai fait TDD depuis 4 ans maintenant et rarement usage privé plus.

Et les tests unitaires serait vite (note, c'est à l'aide de la MSTEST cadre de VS2012)

[TestClass]
public class UnitTest1
{
#region TestHelpers
private ITnEntry MakeEntry(string ticker)
{
return new TnEntry {Ticker = ticker, List = new Ticket()};
}
#endregion
[TestMethod]
public void IsValidEntry_WithValidValues_ReturnsTrue()
{
//ARRANGE
var target = new EntryValidator();
var selectedEntry = MakeEntry("BOL");
//ACT
bool actual = target.IsValidEntry(selectedEntry, selectedEntry.Ticker);
//ASSERT
Assert.IsTrue(actual);
}
[TestMethod]
public void IsValidEntry_WithInValidTicker_ReturnsFalse()
{
//ARRANGE
var target = new EntryValidator();
var selectedEntry = MakeEntry("");
//ACT
bool actual = target.IsValidEntry(selectedEntry, selectedEntry.Ticker);
//ASSERT
Assert.IsFalse(actual);
}
[TestMethod]        
public void IsValidEntry_WithInvalidTicker_RaisesEvent()
{
//ARRANGE
//generate a dynamic mock which will stub all virtual methods
var target = Rhino.Mocks.MockRepository.GenerateMock<EntryValidator>();
var selectedEntry = MakeEntry("");
//ACT
bool actual = target.IsValidEntry(selectedEntry, selectedEntry.Ticker);
//ASSERT
//assert that RaiseInvalidEntryEvent was called
target.AssertWasCalled(x => x.RaiseInvalidEntryEvent(Arg<ITnEntry>.Is.Anything));
}
[TestMethod]
public void RaiseInvalidEntryEvent_WithValidHandler_CallsDelegate()
{
//ARRANGE
var target = new EntryValidator();
var selectedEntry = MakeEntry("");
bool delegateCalled = false;
//attach a handler to set delegateCalled to true
target.OnInvalidEntry += delegate 
{
delegateCalled = true;
};
//ACT
target.IsValidEntry(selectedEntry, selectedEntry.Ticker);
//ASSERT
Assert.IsTrue(delegateCalled);
}
}

OriginalL'auteur nrjohnstone

1

Votre test doit s'abonner à l'événement OnInvalidEntry avec un mannequin méthode, appel IsValidEntry et vérifiez le résultat.

OriginalL'auteur EkoostikMartin

Vous devez vous connecter pour publier un commentaire.