mostrar - obtener el ultimo elemento de una lista c#

¿Usando Moq para verificar un parámetro de tipo Lista<>?

Question

Con Moq, me gustaría poder verificar que se cumplan ciertas condiciones en un parámetro que se pasa a una llamada de método simulado. En este escenario, me gustaría verificar que la lista que se pasó al método simulado sea de un cierto tamaño:

var mockSomeRepository = new Mock<SomeRepository>();
mockSomeRepository.Setup(m => m.Write(It.IsAny<List<SomeDTO>>())).Verifiable();

var mainClass = new MainClass(mockSomeRepository.Object);
List<SomeDTO> someList = GetListWith25Items();

mainClass.DoRepositoryWrite(someList); // calls SomeRepository.Write(someList);

mockSomeRepository.Verify(m => 
    m.Write(It.Is<List<SomeDTO>>(l => l.Count() == 25)), Times.Once());

El verificador de verificación lanza una excepción que dice que el método nunca se llama de esta manera. Sin embargo, eliminar la restricción y usar Is.Any<List<SomeDTO>>() lugar lleva a un pase. No estoy seguro de si estoy usando It.Is <> () correctamente aquí. Esto es lo que intuitivamente quiero que se vea mi prueba, pero no estoy seguro de si estoy usando el marco correctamente. ¿Cómo debo encuadrar adecuadamente esta prueba?

Answer 1

Cuando publiqué esta pregunta, me faltaban algunos detalles importantes. Quiero explicar qué sucedió realmente en caso de que ayude a alguien en el futuro. Mi método bajo prueba en realidad estaba borrando la lista que se estaba pasando al simulacro:

public class SomeDTO { }

public class SomeRepository
{
    public virtual void Write(IEnumerable<SomeDTO> list) { }
}

public class MainClass
{
    private readonly SomeRepository _someRepository;
    private readonly List<SomeDTO> _testList = new List<SomeDTO>(); 

    public MainClass(SomeRepository someRepository)
    {
        _someRepository = someRepository;
    }

    public void DoRepositoryWrite()
    {
        _testList.AddRange(Enumerable.Repeat(new SomeDTO(), 25));
        _someRepository.Write(_testList);
        _testList.Clear();
    }
}

class Program
{
    static void Main(string[] args)
    {
        var mockSomeRepository = new Mock<SomeRepository>();

        var mainClass = new MainClass(mockSomeRepository.Object);

        mainClass.DoRepositoryWrite();

        mockSomeRepository.Verify(m => m.Write(It.IsAny<IEnumerable<SomeDTO>>()), Times.Once(), "Write was not called");
        mockSomeRepository.Verify(m => m.Write(It.Is<IEnumerable<SomeDTO>>(l => l.Count() == 25)), Times.Once(), "Write was not called with a 25-element-list");
    }
}

Mirar hacia atrás parece un poco obvio, pero lo que sí me parece es que el simulacro se aferra a una referencia a la lista que se aprobó. Por lo tanto, debe tener cuidado con los efectos secundarios que alteran esa lista.

Para escribir la prueba correctamente, tuve que inspeccionar las propiedades de la lista aprobada inmediatamente cuando se llamó al método simulado. Para hacer esto utilicé una devolución de llamada:

int listCountAtTimeOfCall = 0;
mockSomeRepository.Setup(
    m => m.Write(It.IsAny<IEnumerable<SomeDTO>>())).Callback
        <IEnumerable<SomeDTO>>(list => listCountAtTimeOfCall = list.Count());

... do the work ...

Assert.AreEqual(listCountAtTimeOfCall, 25);

Answer 2

Puede deshacerse de la llamada a la configuración y verificables en su simulacro. Sólo tiene que utilizar verificar .

Creé un pequeño proyecto de prueba, y esto funcionó para mí:

using System;
using System.Collections.Generic;
using System.Linq;
using Moq;

namespace csharp
{
    public class SomeDTO { }

    public class SomeRepository { public virtual void Write(List<SomeDTO> list) { } }

    public class MainClass
    {
        private SomeRepository someRepository;

        public MainClass(SomeRepository someRepository) { this.someRepository = someRepository; }

        public void DoRepositoryWrite(List<SomeDTO> list) { this.someRepository.Write(list); }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var mockSomeRepository = new Mock<SomeRepository>();
            var someList = Enumerable.Repeat(new SomeDTO(), 25).ToList();

            var mainClass = new MainClass(mockSomeRepository.Object);
            mainClass.DoRepositoryWrite(someList);

            mockSomeRepository.Verify(m => m.Write(It.IsAny<List<SomeDTO>>()), Times.Once(), "Write was not called");
            mockSomeRepository.Verify(m => m.Write(It.Is<List<SomeDTO>>(l => l.Count == 25)), Times.Once(), "Write was not called with a 25-element-list");
        }
    }
}