Comment écrire un test pour une méthode qui retourne un IEnumerable

Question

J'ai une méthode qui retourne un IEnumerable que je veux pouvoir tester. Pour les entrées de test que j'utiliserai, il retournera environ 10 valeurs. Quelle est la manière la plus propre d'écrire un test dans cette situation?

Mise à jour:

Un grand merci pour les réponses à ce jour. Plusieurs suggestions utiles que je vais maintenant étudier.

Je ne pense pas que ma question initiale était très bien formulée, une meilleure façon aurait été la suivante:

Je veux écrire plusieurs tests pour une méthode qui retourne un IEnumerable de KeyValuePair<string, uint>. Pour les ensembles de données de test que j'utiliserai, la méthode retournera seulement quelques valeurs. ~ 10 valeurs dans la plupart des cas. Quelle est la meilleure façon d'exprimer mes valeurs de retour attendues et de tester la méthode dans MSTest?

Answer 1

En supposant que vous sachiez quels résultats devraient être retournés, je trouve que Enumerable.SequenceEqual est utile. (Créez un tableau avec les résultats attendus.)

Dans MoreLINQ J'ai enveloppé cela dans un extension method qui va tester l'égalité et vider les deux séquences si elles ne sont pas égales. En fait, les tests MoreLINQ sont principalement sur le test de l'égalité des séquences, donc ils peuvent vous donner quelques exemples pratiques :)

Answer 2

if(YourMethod(input).Count() != 10) // test failed 

La méthode d'extension Count fonctionne sur IEnumerable et devrait vous permettre de déterminer le nombre d'éléments de la série, si c'est tout ce que vous êtes après. S'assure juste que vous incluez System.Linq.

Answer 3

Si vous utilisez MSTest, comme je suppose, consultez la classe CollectionAssert.

Vous devrez cependant être plus précis que "approximativement 10 valeurs", cependant, si vous voulez écrire un test unitaire approprié.

Answer 4

Vous ne savez pas à quoi vous en êtes, pouvez-vous clarifier?

Pour moi, les tests devraient tester les situations attendues et inattendues. Ils devraient tester les situations limites et typiques.

Dans votre cas, je testerais null, vide, une entrée et plus d'une entrée (par exemple, votre dix typique). Vous connaîtrez le code qui génère l'IEnumerable, vous devriez donc être en mesure de décider quelles autres limites il y a.

Answer 5

Je trouve le manque d'assertion pour IEnumerables malheureux dans CollectionAsserts.

J'ai donc créé les suivantes:

internal static class EnumerableAsserts 
{ 
    public static void AreEqual<T>(
     IEnumerable<T> expected, 
     IEnumerable<T> actual) 
    { 
    AreEqual(expected, actual, null); 
    } 

    public static void AreEqual<T>(
    IEnumerable<T> expected, 
    IEnumerable<T> actual, 
    string text) 
    { 
    text = text == null ? "" : text +" : "; 
    if (expected == null) 
     Assert.Fail("{0}expected is null!", text); 
    if (actual == null) 
     Assert.Fail("{0}actual is null!", text); 
    if (ReferenceEquals(expected, actual)) 
     return; 
    var e = expected.GetEnumerator(); 
    var a = actual.GetEnumerator(); 
    int count = 0; 
    while (e.MoveNext()) 
    { 
     count++; 
     if (a.MoveNext()) 
     { 
     if (!EqualityComparer<T>.Default.Equals(e.Current, a.Current)) 
      Assert.Fail(
      "{0}the {1}{2} item did not match expected '{3}' but was '{4}'", 
      text, count, MathUtils.GetOrdinal(count), e.Current, a.Current); 
     } 
     else 
     { 
     Assert.Fail(
      "{0}there were {1} expected entries but {2} actual entries", 
      text, expected.Count(), actual.Count()); 
     } 
    } 
    if (a.MoveNext()) 
     Assert.Fail(
     "{0}there were {1} expected entries but {2} actual entries", 
     text, expected.Count(), actual.Count()); 
    } 
}