unit testing - unit - La invocación de Moq no se realizó en el simulacro

unit testing with mocks

Question

Tratando de entender el uso de verifySet, etc., pero a menos que haga una solución no puedo hacer que funcione.

public interface IProduct
{
    int  Id { get; set; }
    string Name { get; set; }
}


public void Can_do_something()
{
    var newProduct = new Mock<IProduct>();
    newProduct.SetupGet(p => p.Id).Returns(1);
    newProduct.SetupGet(p => p.Name).Returns("Jo");

    //This fails!! why is it because I have not invoked it
    newProduct.VerifySet(p => p.Name, Times.AtLeastOnce());

    //if I do this it works
    newProduct.Object.Name = "Jo";
    newProduct.VerifySet(p => p.Name, Times.AtLeastOnce());
 }

¿Alguien puede aclarar cómo debería usar VerifySet y verificar y verificar Get en una propiedad? Me estoy confundiendo

Answer 1

Está utilizando VerifySet () de la manera correcta, acaba de omitir la etapa // Act desde el típico

//Arrange

//Act

//Assert

construcción de prueba. Como sugirió, insertando

newProduct.Object.Name = "Jo";

en su etapa // Actúa corrige el problema.

VerifyGet () se usaría de la misma manera, por ejemplo

//Arrange
var newProduct = new Mock<IProduct>();
newProduct.SetupGet(p => p.Id).Returns(1);
newProduct.SetupGet(p => p.Name).Returns("Jo");

//Act
string productName = newProduct.Object.Name;

//Assert
newProduct.VerifyGet(p => p.Name, Times.AtLeastOnce());

newProduct.Verify () se utiliza para verificar cualquier acción que especifique, por ejemplo

//Arrange
var newProduct = new Mock<IProduct>();
newProduct.SetupGet(p => p.Id).Returns(1);
newProduct.SetupGet(p => p.Name).Returns("Jo");

//Act
newProduct.Object.SomeMethodYouDefineOnTheProductObject();

//Assert
newProduct.Verify(p => p.SomeMethodYouDefineOnTheProductObject(), Times.AtLeastOnce());

Answer 2

Organizar:

Instruya a los objetos falsos sobre lo que sucederá durante la prueba. Dígale qué eventos se dispararán, qué métodos y propiedades se usarán y qué hacer cuando sucedan estas cosas.

Acto:

Ejercita el código bajo prueba.

Afirmar:

Pregúntale a los objetos falsos si sucedió lo que les dijiste que esperaban. También inspeccione su código para ver si funcionó como esperaba.

Tu problema es que arreglaste y luego afirmaste sin actuar en medio. La serie de métodos de Verify afirma que lo que dijo que sucedería en los métodos de instalación realmente sucedió.

Answer 3

Gracias chicos Lamentablemente, soy nuevo en todo esto y trato de aprender rápido. Especialmente la terminología "actuar", "organizar", etc.

Entonces, aunque no entendí lo que estaba haciendo, lo hice correctamente

newProduct.Object.Name = "Jo";

estaba preparando un acto.

Explicación fantástica muchachos muchas gracias

Una última cosa, aunque pensé que estos "configurar y actuar", pero no es el caso correcto ¿verdad? ¿conoces el diff también entre los dos SetupProperty y SetupSet / Get?

mock.SetupProperty (f => f.Surname, "foo");

mock.SetupSet (foo => foo.Surname = "foo");

Answer 4

Debe realizar una acción antes de llamar a verificar. El paradigma típico de prueba unitaria con objetos simulados es:

// Arrange
// Act
// Assert

Por lo tanto, lo siguiente es un uso incorrecto porque le falta su paso de Ley:

public void Can_do_something()
{
    // Arrange
    var newProduct = new Mock<IProduct>();
    newProduct.SetupGet(p => p.Name).Returns("Jo");

    // Act - doesn''t exist!
    // Your action against p.Name (ie method call), should occur here

    // Assert
    // This fails because p.Name has not had an action performed against it
    newProduct.VerifySet(p => p.Name, Times.AtLeastOnce());
}

Y esto es correcto, ya que existe el acto:

public void Can_do_something()
{
    // Arrange
    var newProduct = new Mock<IProduct>();
    newProduct.SetupGet(p => p.Name).Returns("Jo");

    // Act
    LoadProduct(newProduct.Object);

    // Assert
    newProduct.VerifySet(p => p.Name, Times.AtLeastOnce());
}

public static void LoadProduct(IProduct product)
{
    product.Name = "Jo";
}

Las pruebas simuladas siguen un patrón diferente al de las pruebas no falsas conocidas como verificación de comportamiento : esta es una respuesta que hice que aclarará el concepto un poco más.