unit-testing
Prueba de dobles

Observaciones

Usando un talón para suministrar respuestas enlatadas

Un talón es una prueba de peso ligero doble que proporciona respuestas enlatadas cuando se llama a los métodos. Cuando una clase bajo prueba se basa en una interfaz o clase base, se puede implementar una clase alternativa 'stub' para realizar pruebas que se ajusten a la interfaz.

Entonces, asumiendo la siguiente interfaz,

public interface IRecordProvider {
    IEnumerable<Record> GetRecords();
}

Si el siguiente método fuera a ser probado

public bool ProcessRecord(IRecordProvider provider)

Se puede escribir una clase de código auxiliar que implementa la interfaz para devolver datos conocidos al método que se está probando.

public class RecordProviderStub : IRecordProvider
{
    public IEnumerable<Record> GetRecords()
    {
        return new List<Record> {
            new Record { Id = 1, Flag=false, Value="First" },
            new Record { Id = 2, Flag=true, Value="Second" },
            new Record { Id = 3, Flag=false, Value="Third" }
        };
    }
}

Esta implementación de código auxiliar se puede proporcionar al sistema bajo prueba para influir en su comportamiento.

var stub = new RecordProviderStub();
var processed = sut.ProcessRecord(stub);

Usando un marco de burla como un trozo

Los términos Mock y Stub a menudo pueden confundirse. Parte de la razón de esto es que muchos marcos de simulacros también brindan soporte para crear Stubs sin el paso de verificación asociado con Mocking.

En lugar de escribir una nueva clase para implementar un código auxiliar como en el ejemplo "Usar un código auxiliar para proporcionar respuestas enlatadas", se pueden usar marcos burlones.

Utilizando Moq:

var stub = new Mock<IRecordProvider>();
stub.Setup(provider => provider.GetRecords()).Returns(new List<Record> {
    new Record { Id = 1, Flag=false, Value="First" },
    new Record { Id = 2, Flag=true, Value="Second" },
    new Record { Id = 3, Flag=false, Value="Third" }
});

Esto logra el mismo comportamiento que el código codificado a mano, y se puede suministrar al sistema bajo prueba de una manera similar:

var processed = sut.ProcessRecord(stub.Object);

Usando un marco de burla para validar el comportamiento

Las simulaciones se utilizan cuando es necesario verificar las interacciones entre el sistema sometido a prueba y la prueba de dobles. Se debe tener cuidado para evitar crear pruebas demasiado frágiles, pero la burla puede ser particularmente útil cuando el método para probar es simplemente organizar otras llamadas.

Esta prueba verifica que cuando se llama al método bajo prueba ( ProcessRecord ), se llama al método de servicio ( UseValue ) para el Record donde Flag==true . Para ello, configura un apéndice con datos enlatados:

var stub = new Mock<IRecordProvider>();
stub.Setup(provider => provider.GetRecords()).Returns(new List<Record> {
    new Record { Id = 1, Flag=false, Value="First" },
    new Record { Id = 2, Flag=true, Value="Second" },
    new Record { Id = 3, Flag=false, Value="Third" }
});

Luego configura un simulacro que implementa la interfaz IService :

var mockService = new Mock<IService>();
mockService.Setup(service => service.UseValue(It.IsAny<string>())).Returns(true);

Luego se suministran al sistema bajo prueba y se llama al método a probar.

var sut = new SystemUnderTest(mockService.Object);

var processed = sut.ProcessRecord(stub.Object);

El simulacro puede ser interrogado para verificar que se haya realizado la llamada esperada. En este caso, una llamada a UseValue , con un parámetro "Segundo", que es el valor del registro donde Flag==true .

mockService.Verify(service => service.UseValue("Second"));