que - ¿Cuál es el mejor framework simulado para Java?
manual de hibernate eclipse (14)
Comencé a usar EasyMock con EasyMock . Lo suficientemente fácil de entender, pero el paso de repetición fue un poco molesto. Mockito elimina esto, también tiene una sintaxis más limpia, ya que parece que la legibilidad era uno de sus objetivos principales. No puedo enfatizar lo importante que es esto, ya que la mayoría de los desarrolladores dedicarán su tiempo a leer y mantener el código existente, no a crearlo.
Otra cosa buena es que las interfaces y las clases de implementación se manejan de la misma manera, a diferencia de EasyMock, donde aún necesita recordar (y verificar) para usar una extensión de clase EasyMock.
He echado un vistazo rápido a JMockit recientemente, y aunque la JMockit lista de características es bastante completa, creo que el precio de esto es la legibilidad del código resultante y tener que escribir más.
Para mí, Mockito es el lugar ideal, es fácil de escribir y leer, y de resolver la mayoría de las situaciones que requerirá la mayoría de los códigos. Usar Mockito con PowerMock sería mi elección.
Una cosa a tener en cuenta es que la herramienta que elegiría si estuviera desarrollando por su cuenta o en un equipo pequeño, podría no ser lo mejor para una gran empresa con desarrolladores de diferentes niveles de habilidad. La legibilidad, la facilidad de uso y la simplicidad necesitarían más consideración en este último caso. No tiene sentido obtener el marco de burla definitivo si muchas personas no lo usan o no mantienen las pruebas.
¿Cuál es el mejor marco para crear objetos simulados en Java? ¿Por qué? ¿Cuáles son los pros y los contras de cada marco?
Comencé a usar simulacros a través de JMock, pero finalmente hice la transición para usar EasyMock. EasyMock era solo eso, más fácil, y proporcionaba una sintaxis que se sentía más natural. No he cambiado desde entonces.
El JMockit contiene mucha información comparativa para los kits de herramientas de JMockit actuales.
En particular, revise la matriz de comparación de características , que cubre EasyMock, jMock, Mockito, Unitils Mock, PowerMock y, por supuesto, JMockit. Trato de mantenerlo preciso y actualizado, tanto como sea posible.
Estamos usando mucho EasyMock y EasyMock Class Extension en el trabajo y estamos muy contentos con ello. Básicamente te da todo lo que necesitas. Eche un vistazo a la documentación, hay un buen ejemplo que le muestra todas las características de EasyMock.
He estado teniendo éxito con JMockit .
Es bastante nuevo, por lo que es un poco crudo y poco documentado. Utiliza ASM para redefinir dinámicamente el bytecode de clase, de modo que puede simular todos los métodos, incluidos los inicializadores estáticos, privados, constructores y estáticos. Por ejemplo:
import mockit.Mockit;
...
Mockit.redefineMethods(MyClassWithStaticInit.class,
MyReplacementClass.class);
...
class MyReplacementClass {
public void $init() {...} // replace default constructor
public static void $clinit{...} // replace static initializer
public static void myStatic{...} // replace static method
// etc...
}
Tiene una interfaz de Expectativas que permite también grabar / reproducir escenarios:
import mockit.Expectations;
import org.testng.annotations.Test;
public class ExpecationsTest {
private MyClass obj;
@Test
public void testFoo() {
new Expectations(true) {
MyClass c;
{
obj = c;
invokeReturning(c.getFoo("foo", false), "bas");
}
};
assert "bas".equals(obj.getFoo("foo", false));
Expectations.assertSatisfied();
}
public static class MyClass {
public String getFoo(String str, boolean bool) {
if (bool) {
return "foo";
} else {
return "bar";
}
}
}
}
El inconveniente es que requiere Java 5/6.
He tenido un buen éxito usando Mockito .
Cuando intenté aprender sobre JMock y EasyMock, encontré que la curva de aprendizaje era un poco empinada (aunque tal vez sea solo yo).
Me gusta Mockito debido a su sintaxis simple y limpia que pude captar rápidamente. La sintaxis mínima está diseñada para soportar muy bien los casos comunes, aunque las pocas veces que tuve que hacer algo más complicado, encontré que lo que quería era compatible y fácil de entender.
Aquí hay un ejemplo (resumido) de la página de inicio de Mockito:
import static org.mockito.Mockito.*;
List mockedList = mock(List.class);
mockedList.clear();
verify(mockedList).clear();
No puede ser mucho más simple que eso.
El único inconveniente importante que se me ocurre es que no se burlará de los métodos estáticos.
La mejor solución para burlarse es hacer que la máquina haga todo el trabajo con pruebas automatizadas basadas en especificaciones. Para Java, consulte ScalaCheck y el marco de trabajo de Reductio incluido en la biblioteca funcional de Java . Con los marcos de prueba basados en especificaciones automáticas, proporciona una especificación del método bajo prueba (una propiedad que debería ser cierta) y el marco genera pruebas y simula los objetos automáticamente.
Por ejemplo, la siguiente propiedad prueba el método Math.sqrt para ver si la raíz cuadrada de cualquier número positivo n al cuadrado es igual a n.
val propSqrt = forAll { (n: Int) => (n >= 0) ==> scala.Math.sqrt(n*n) == n }
Cuando llama a propSqrt.check() , ScalaCheck genera cientos de enteros y verifica su propiedad para cada uno, asegurándose automáticamente de que los casos de borde estén bien cubiertos.
Aunque ScalaCheck está escrito en Scala y requiere el compilador de Scala, es fácil probar el código Java con él. El marco de Reductio en Java funcional es una implementación Java pura de los mismos conceptos.
Me gusta JMock porque eres capaz de establecer expectativas. Esto es totalmente diferente de verificar si un método fue llamado encontrado en algunas bibliotecas simuladas. Usando JMock puedes escribir expectativas muy sofisticadas. Ver el cheat-sheat .
Mockito también ofrece la opción de métodos de apéndice, argumentos coincidentes (como anyInt () y anyString ()), verificando el número de invocaciones (times (3), atLeastOnce (), never ()) y más .
También he encontrado que Mockito es simple y limpio .
Una cosa que no me gusta de Mockito es que no puedes eliminar métodos estáticos .
Sí, Mockito es un gran marco. Lo uso junto con hamcrest y Google Guice para configurar mis pruebas.
Soy el creador de PowerMock, así que obviamente debo recomendarlo. :-)
PowerMock extiende tanto EasyMock como Mockito con la capacidad de simular métodos estáticos , finales e incluso métodos privados. La compatibilidad con EasyMock está completa, pero el complemento Mockito necesita un poco más de trabajo. También estamos planeando agregar soporte de JMock.
PowerMock no pretende reemplazar otros marcos, sino que se puede usar en situaciones difíciles cuando otros marcos no permiten burlarse. PowerMock también contiene otras características útiles, como la supresión de inicializadores y constructores estáticos .
También puedes echar un vistazo a las pruebas usando Groovy. En Groovy puedes simular fácilmente las interfaces de Java usando el operador ''como'':
def request = [isUserInRole: { roleName -> roleName == "testRole"}] as HttpServletRequest
Además de esta funcionalidad básica, Groovy ofrece mucho más en el frente burlón, incluidas las poderosas clases MockFor y StubFor .
Utilicé JMock temprano. He probado Mockito en mi último proyecto y me ha gustado. Más conciso, más limpio. PowerMock cubre todas las necesidades que están ausentes en Mockito, como simular un código estático, simular una creación de instancia, burlarse de clases y métodos finales. Así que tengo todo lo que necesito para realizar mi trabajo.