Mock framework vs MS Fakes frameworks

Un poco confundido sobre las diferencias de los frameworks de Mock como NMock versus el framework de falsificaciones VS 2011. Pasando por MSDN, lo que entiendo es que las falsificaciones te permiten burlar tus dependencias al igual que RhinoMock o NMock; sin embargo, el enfoque es diferente, Fakes genera código para lograr esta funcionalidad, pero el marco de Mocks no. Entonces, ¿es correcto mi entendimiento? Es falso otro marco falso

Su pregunta fue acerca de cómo el marco de MS Fakes es diferente de NMock y parece que las otras respuestas han resuelto algo de eso, pero aquí hay más información sobre cómo son iguales y cómo son diferentes. NMock también es similar a RhinoMocks y Moq, así que los estoy agrupando con NMock.

Hay 3 diferencias principales que veo inmediatamente entre NMock / RhinoMocks / Moq y el MS Fakes Framework:

  • El framework de falsificaciones MS usa código generado, al igual que los Accessors en versiones anteriores de Visual Studio en lugar de los tipos generics. Cuando desee utilizar el marco falso para una dependencia, agregue el conjunto que contiene la dependencia a las referencias del proyecto de prueba y luego haga clic derecho sobre él para generar los dobles de prueba (talones o cuñas). Luego, cuando está probando, en realidad está usando estas clases generadas. NMock usa generics para lograr lo mismo (es decir, IStudentRepository studentRepository = mocks.NewMock() ). En mi opinión, el enfoque del framework MS Fakes inhibe la navegación y la refactorización del código desde las pruebas, ya que en realidad estás trabajando contra una clase generada, no contra tu interfaz real.

  • La MS falsifica stubs y topos (cuñas) de suministros de framework, mientras que NMock, RhinoMocks y Moq proporcionan topes y burlas . Realmente no entiendo la decisión de MS de no incluir burlas y, personalmente, no soy fanático de los lunares por los motivos que se describen a continuación.

  • Con el marco de falsificaciones de MS, usted proporciona una implementación alternativa de los métodos que desea almacenar. Dentro de estas implementaciones alternativas, puede especificar los valores de retorno y la información de seguimiento acerca de cómo o si se llamó al método. Con NMock, RhinoMocks y Moq, generas un objeto falso y luego usas ese objeto para especificar los valores de retorno anulados o para rastrear las interacciones (si y cómo se llamaron los métodos). Encuentro que el enfoque de las falsificaciones de MS es más complejo y menos expresivo.

Para aclarar la diferencia en lo que proporcionan los marcos: NMock, RhinoMocks y Moq proporcionan dos tipos de dobles de prueba (stubs y mocks). El marco falso proporciona talones y topos (los llaman calzas), y desafortunadamente no incluye simulacros. Para entender las diferencias y similitudes entre NMock y MS Fakes, es útil entender qué son estos diferentes tipos de dobles de prueba:

Trozos: Los trozos se usan cuando necesita proporcionar un valor para los métodos o propiedades que se le pedirán a su prueba de dobles por el método bajo prueba. Por ejemplo, cuando mi método bajo prueba llama al método DoesStudentExist () de la prueba IStudentRepository double, quiero que devuelva verdadero.

La idea de los stubs en NMock y MS falsificaciones es la misma, pero con NMock harías algo como esto:

 Stub.On(mockStudentRepository).Method("DoesStudentExist").Will(Return.Value(true)); 

Y con MSFakes harías algo así:

 IStudentRepository studentRepository = new DataAccess.Fakes.StubIStudentRepository() // Generated by Fakes. { DoesStudentExistInt32 = (studentId) => { return new Student(); } }; 

Observe que en el ejemplo de MS Fakes crea una implementación completamente nueva para el método DoesStudentExist (tenga en cuenta que se llama DoesStudentExistInt32 porque el marco falso anexa los tipos de datos de parámetros a los nombres de los métodos cuando genera los objetos de tallo, creo que esto oscurece la claridad de los exámenes). Para ser sincero, la implementación de NMock también me molesta porque usa una cadena para identificar el nombre del método. (Perdóneme si he entendido mal cómo se va a utilizar NMock.) Este enfoque realmente inhibe la refactorización y recomiendo encarecidamente RhinoMocks o Moq sobre NMock por este motivo.

Mocks: los simulacros se utilizan para verificar la interacción entre el método bajo prueba y sus dependencias. Con NMock, puede hacer esto estableciendo expectativas similares a esta:

 Expect.Once.On(mockStudentRepository).Method("Find").With(123); 

Esta es otra razón por la que preferiría RhinoMocks y Moq a NMock, NMock usa el estilo de expectativa más antiguo, mientras que RhinoMocks y Moq admiten el enfoque Arrange / Act / Assert donde especifica las interacciones esperadas como aserciones al final de la prueba como este :

 stubStudentRepository.AssertWasCalled( x => x.Find(123)); 

Una vez más, tenga en cuenta que RhinoMocks utiliza una lambda en lugar de una cadena para identificar el método. El framework ms fakes no proporciona ningún simulacro. Esto significa que en las implementaciones finalizadas (consulte la descripción de los apéndices anteriores), debe establecer las variables que luego verifique que se hayan configurado correctamente. Eso se vería así:

 bool wasFindCalled = false; IStudentRepository studentRepository = new DataAccess.Fakes.StubIStudentRepository() { DoesStudentExistInt32 = (studentId) => { wasFindCalled = true; return new Student(); } }; classUnderTest.MethodUnderTest(); Assert.IsTrue(wasFindCalled); 

Encuentro que este enfoque es un poco intrincado ya que tiene que seguir la llamada en el talón y luego afirmarlo más tarde en la prueba. Me parece que los ejemplos de NMock, y especialmente los de RhinoMocks, son más expresivos.

Moles (Calzas): Para ser sincero, no me gustan los lunares, debido a su potencial de mal uso. Una de las cosas que más me gusta de las pruebas unitarias (y TDD en particular) es que probar tu código te ayuda a entender dónde has escrito un código pobre. Esto se debe a que es difícil probar el código mal escrito. Esto no es cierto cuando se usan moles porque los topos en realidad están diseñados para permitirle probar contra dependencias que no se inyectan o para probar métodos privados. Funcionan de manera similar a los stubs, excepto que utiliza un ShimsContext como este:

 using (ShimsContext.Create()) { System.Fakes.ShimDateTime.NowGet = () => { return new DateTime(fixedYear, 1, 1); }; } 

Mi preocupación con las calzas es que la gente comenzará a verlas como “una forma más fácil de probar la unidad” porque no te obliga a escribir el código de la manera que deberías. Para una reseña más completa sobre este concepto, vea este post mío:

Para obtener más información sobre algunas inquietudes relacionadas con los marcos falsos, eche un vistazo a estas publicaciones:

Si está interesado en aprender RhinoMocks, aquí hay un video de capacitación de Pluralsight (divulgación completa: escribí este curso y recibí regalías por las reproducciones, pero creo que se aplica a esta discusión, por lo que lo incluyo aquí):

Tienes razón, pero hay más en la historia. Las cosas más importantes que se pueden quitar de esta respuesta son:

  1. Su architecture debe hacer un uso adecuado de los stubs y la dependency injection, en lugar de depender de la muleta de Fakes and Mocks.

  2. Las falsificaciones y los simulacros son útiles para probar código que no debe o no puede cambiar, como por ejemplo:

    • Código heredado que no hace uso (o uso eficiente) de stubs
    • API de terceros
    • Recursos para los cuales no tienes código fuente

Shims (conocido como “Moles”, durante el desarrollo) es de hecho un marco de burla que opera por medio de desvíos de llamadas. En lugar de construir minuciosamente un simulacro (¡sí, incluso el uso de Moq es relativamente doloroso!), Las calzas simplemente usan el objeto de código de producción que ya está en su lugar. Las cuñas simplemente redirigen la llamada del objective de producción al delegado de prueba.

Los stubs se generan a partir de interfaces en el proyecto de destino. El objeto Stub es solo eso: una implementación de la interfaz. El beneficio de utilizar el tipo de Stub es que puede generar rápidamente un stub sin complicar su proyecto de prueba con muchos stubs de uso únicos, sin mencionar el desperdicio de tiempo en crearlos. Por supuesto, aún debe crear trozos de hormigón para su uso en muchas pruebas.

La implementación eficiente de Fakes (calzas, simulacros y tipos de trozos) requiere un poco de tiempo para acostumbrarse, pero vale la pena el esfuerzo. Personalmente he ahorrado semanas de tiempo de desarrollo, mediante el uso de los tipos Shims / Mole, Mocks y Stub. ¡Espero que se divierta tanto con la tecnología como yo!

Según tengo entendido, el equipo de Visual Studio quería evitar competir con las diversas bibliotecas de simulacro disponibles para .NET. La EM a menudo enfrenta decisiones difíciles como esta. Son reprimidos si no proporcionan cierta funcionalidad (“¿por qué MS no nos proporciona una biblioteca simulada? ¿Los burlas son un requisito tan común?”) Y malditos si lo hacen (“¿por qué Microsoft actúa tan agresivamente y manejando su partidarios naturales fuera del mercado? “) Muy a menudo, pero no siempre, deciden evitar simplemente proporcionar su propia alternativa a las tecnologías disponibles y bien recibidas. Ese parece ser el caso aquí.

La función de corrección de Fakes es realmente útil. Claro, hay peligros. Se requiere cierta disciplina para garantizar que solo use esto cuando sea necesario. Sin embargo, llena una gran brecha. Mi principal queja es que solo se entrega con la edición Ultimate de VS 2012 y, por lo tanto, solo estará disponible para una subsección de la comunidad de desarrollo de .NET. Qué pena.

Las falsificaciones incluyen dos tipos diferentes de objetos “falsos”. El primero, llamado “stub”, es esencialmente un maniquí generado automáticamente cuyo comportamiento predeterminado puede (y normalmente) ser anulado para que sea un simulacro más interesante. Sin embargo, carece de algunas de las características que ofrecen la mayoría de los marcos de burla actualmente disponibles. Por ejemplo, si desea verificar que se invocó un método en una instancia de código auxiliar, deberá agregar la lógica para esto usted mismo. Básicamente, si estás creando tus propios burlas manualmente ahora, los talones probablemente parezcan una mejora. Sin embargo, si ya está utilizando un marco de burla más completo, es posible que sienta que faltan algunas piezas importantes en los talones de Fakes.

La otra categoría de objeto ofrecida por Fakes, llamada “shim”, expone un mecanismo para reemplazar el comportamiento de dependencias que no han sido (o no pueden ser) desacopladas adecuadamente para el reemplazo estándar a través de simulacros. AFAIK, TypeMock es el único de los principales marcos de burla que actualmente ofrece este tipo de funcionalidad.

Por cierto, si ha probado antes Moles, Fakes es esencialmente lo mismo, finalmente saliendo de Microsoft Research y convirtiéndose en un producto real.

En cuanto a los objetos Fake (Shim + Stub), se ha definido bien arriba, aunque creo que el último párrafo del último comentario resume bastante bien la situación.

Aunque mucha gente argumentará que los objetos Fake (Shim + Stub) son buenos activos para tener en algunos casos de pruebas unitarias, la desventaja es que no importa si está usando Visual Studio 2012 o Visual Studio 2013, estas opciones están SOLO disponibles con versiones Premium o Ultimate. IOW, esto significa que NO deberás ejecutar CUALQUIERA de esas falsificaciones (Shim + Stub) en cualquier versión Pro.

Es probable que veas la opción de menú Fakes (Shim + Stub) en las versiones Pro, pero ten cuidado, hay algunas posibilidades bastante fuertes de que termines con absolutamente nada … No generará ningún error de comstackción que te diga que algo importante falta, las opciones simplemente no existen, así que no pierdas tu tiempo …

Es un factor importante a tener en cuenta en un equipo de desarrollo, especialmente si uno es el único que utiliza la versión Ultimate mientras que todos los demás usan la versión Pro … Moq puede instalarse fácilmente a través de Nuget sin importar la versión de Visual Studio que use. No tuve problemas para usar Moq, la clave con cualquier herramienta es saber para qué se usan y cómo usarlas correctamente;)

Intereting Posts