Mon dernier désastre à cause des moqueries n'est pas le fait que j'ai besoin de pousser les résultats dans un objet fictif de IEnumerable<T>.

Voici un exemple (démonstration uniquement de IEnumerable<T>, pas vraiment de bons tests basés sur l'interaction !) :

using System;
using System.Collections.Generic;
using Rhino.Mocks;
using MbUnit.Framework;

[TestFixture]
public class ZooTest
{
    [Test]
    public void ZooCagesAnimals()
    {
        MockRepository mockery = new MockRepository();

        IZoo zoo = new Zoo();

        // This is the part that feels wrong to create.
        IList<IAnimal> mockResults = mockery.DynamicMock<IList<IAnimal>>();
        IAnimal mockLion = mockery.DynamicMock<IAnimal>();
        IAnimal mockRhino = mockery.DynamicMock<IAnimal>();

        using (mockery.Record())
        {
            Expect.Call(zoo.Animals)
                .Return(mockResults)
                .Repeat.Once();
        }

        using (mockery.Playback())
        {
            zoo.CageThe(mockLion);
            zoo.CageThe(mockRhino);

            Assert.AreEqual(mockResults, new List<IAnimal>(zoo.Animals));
        }       
    }
}


public class Zoo : IZoo
{
    private IList<IAnimal> animals = new List<IAnimal>();

    public void CageThe(IAnimal animal)
    {
        animals.Add(animal);
    }

    public IEnumerable<IAnimal> Animals
    {
        get
        {
            foreach(IAnimal animal in animals)
            {
                yield return animal;
            }
        }
    }
}

public interface IAnimal
{
}

public interface IZoo
{
    IEnumerable<IAnimal> Animals { get;}
    void CageThe(IAnimal animal);
}

Je n'aime pas la façon dont je l'ai fait fonctionner pour les raisons suivantes :

• Consommer les résultats IEnumerable<IAnimal> en IList<IAnimal> - parce que je comprends que cela met les résultats à vérifier sur le tas.
• Configuration du contenu des résultats - ce que je comprends également ; mais mon point principal est de tester que Zoo.Animals renvoie IEnumerable<IAnimal>, et mieux encore, qu'il utilise yield return à l'intérieur.< /li>

Des suggestions pour faire mieux ou plus simplement ?

Modifier : j'essaie de déterminer la manière optimale de tester l'interaction entre IEnumerable<T> et tout ce que j'utilise. Je n'essaie pas de tester que Zoo peut contenir des animaux, plutôt que Zoo expose comme IEnumerable<IAnimal>, et que 8 s'habitue également.