Comparación entre Mockito vs JMockit - ¿por qué es mejor que votó Mockito JMockit? [cerrado]

Question

Estoy investigando la que burlarse de marco para el uso de mi proyecto y han reducido a JMockit y Mockito .

Me he dado cuenta de que Mockito fue votado " la mejor marco simulacro para Java " en Stackoverflow.
En la comparación de las características de JMockit 's "href="http://rawgit.com/jmockit/jmockit.github.io/e5f649df0276ef561b1b98004914a0cfd0c290bb/MockingToolkitComparisonMatrix.html" herramienta que imita Comparación Matrix " parece que JMockit tiene varias características diferentes.

¿alguien tiene alguna información específica (no opiniones) en lo que Mockito puede hacer lo que no puede ser alcanzado con JMockit y viceversa?

Answer 1

Actualización de Sep de 2019: La única burlándose marco soportado (por defecto) en la primavera de Boot es Mockito . Si utiliza la primavera, la respuesta es bastante obvia.

---

Yo diría que la competencia es entre JMockit y PowerMock y Mockito .

Me dejaría "normal" y jMock EasyMock porque utilizan único indicador y CGLIB y no usan Java 5 instrumentación como los marcos nuevos.

También jMock no tenía una versión estable durante más de 4 años. jMock 2.6.0 requiere 2 años para pasar de RC1 a RC2, y luego otros 2 años antes de que realmente fue liberada.

En cuanto a Proxy y CGLIB vs instrumentación:

  

(EasyMock y jMock) se basan en java.lang.reflect.Proxy,   que requiere una interfaz para ser   implementado. Adicionalmente,   apoyar la creación de objetos simulados   para las clases a través de CGLIB subclase   Generacion. Debido a eso, dijo   clases no pueden ser definitiva y sólo   métodos de instancia reemplazables pueden ser   burlado. Lo más importante, sin embargo,   cuando se utilizan estas herramientas las   dependencias de código bajo prueba (que   Es decir, los objetos de otras clases en   que una clase dada bajo prueba   depends) debe ser controlado por el   pruebas, por lo que los casos simulados pueden ser   pasó a los clientes de los   Dependencias. Por lo tanto, las dependencias   simplemente no puede ser instanciado con el   nuevo operador en una clase de cliente para   lo que queremos escribir pruebas unitarias.

     

En última instancia, las limitaciones técnicas   de herramientas burlones convencionales imponer   las siguientes restricciones de diseño en   Código de producción:

     

  
1. Cada clase que puede que tenga que ser burlado en una prueba o bien debe aplicar   una interfaz o no separado ser final.
  
2. Las dependencias de cada clase a ensayar debe ser obtenido ya sea   a través de creación de la instancia configurable   métodos (fábricas o un Servicio   Locator), o estar expuestos para la dependencia   inyección. De lo contrario, las pruebas unitarias no lo hará   ser capaz de pasar implementaciones simuladas   de dependencias a la unidad bajo   prueba.
  
3. Dado que sólo los métodos de instancia puede ser burlado, clases a ensayar unidad   no puede llamar a cualquiera de los métodos estáticos en   sus dependencias, ni instantiate   utilizando cualquiera de los constructores.
  

Lo anterior se copia de http://jmockit.org/about.html . Además, se compara entre sí (JMockit), PowerMock, y Mockito de varias maneras:

  

En la actualidad hay otras herramientas para burlones   Java que también superar la   limitaciones de los convencionales,   entre ellos PowerMock, jEasyTest, y   MockInject. El que más se acerca   para el conjunto de características de JMockit es   PowerMock, así que voy a evaluar brevemente   aquí (además, los otros dos son   más limitado y no parecen estar   desarrollado activamente más).

     

JMockit vs PowerMock

     

  
• En primer lugar, PowerMock no proporciona una API completa para burlarse,   pero en su lugar funciona como una extensión de   otra herramienta, que en la actualidad puede ser   EasyMock o Mockito. Esto es obviamente   una ventaja para los usuarios existentes de   esas herramientas.
  
• JMockit, por el contrario, ofrece completamente nuevas API, aunque   su API principal (expectativas) es similar   tanto EasyMock y jMock. Mientras esto   crea una curva de aprendizaje más largo, se   también permite JMockit para proporcionar una   más simple, más consistente y más fácil   para uso API.
  
• En comparación con la API de Expectativas JMockit, la API es PowerMock   más "bajo nivel", lo que obliga a los usuarios   averiguar y especificar qué clases   necesidad de estar preparados para la prueba (con   la @PrepareForTest ({ClassA.class,...}) anotación) y que requieren   llamadas a la API específicas para hacer frente a   diversos tipos de construcciones del lenguaje   que pueden estar presentes en la producción   código: métodos estáticos   (MockStatic (ClassA.class)),   constructores   (Suprimir (constructor (ClassXyz.class))),   invocaciones constructor   (ExpectNew (AClass.class)), parcial   burla (createPartialMock (ClassX.class,   "MethodToMock")), etc.
  
• Con las expectativas JMockit, todo tipo de métodos y constructores están   burlado de una manera puramente declarativa,   con burla parcial especifica a través   expresiones regulares en el @Mocked   anotación o simplemente "no-burla"   los miembros con no registrado   Expectativas; es decir, el desarrollador   simplemente declara un poco de "simulacro compartida   campos" de la clase de prueba, o alguna   "Campos simulacros locales" y / o "mock   "parámetros de prueba individual   métodos (y en este último caso la   anotación @Mocked menudo no será   es necesario).
  
• Algunas capacidades disponibles en JMockit, como el soporte para burla   iguales y hashCode, reemplazado   métodos, y otros, no están actualmente   apoyado en PowerMock. Además, hay   hay un equivalente a la capacidad de JMockit a   instancias de captura y simulacro   implementaciones de base especificada   tipos como se ejecuta la prueba, sin   el propio código de prueba que tiene cualquier   conocimiento de la ejecución real   clases.
  
• PowerMock utiliza cargadores de clases personalizados (generalmente uno por cada clase de prueba)   con el fin de generar versiones modificadas   de las clases burlado. Tal uso pesado   de la costumbre cargadores de clases pueden conducir a   conflictos con bibliotecas de terceros,   de ahí la necesidad de utilizar a veces el   @PowerMockIgnore ( "package.to.be.ignored")   anotación en las clases de prueba.
  
• El mecanismo utilizado por JMockit (instrumentación de tiempo de ejecución a través de una   "Agente de Java") es más sencillo y más seguro,   aunque requiere pasar una   parámetro "-javaagent" a la JVM cuando   desarrollo en JDK 1.5; en JDK 1.6 +   (Que siempre se puede utilizar para   desarrollo, aunque el despliegue en una   versión anterior) no hay tal   requisito, ya lata JMockit   transparente cargar el agente de Java en   la demanda mediante el uso de la API Adjuntar.
  

     

Otra herramienta de burla reciente es   Mockito. A pesar de que no intenta   para superar las limitaciones de los mayores   herramientas (JMock, EasyMock), lo hace   introducir un nuevo estilo de comportamiento   las pruebas con burla. también JMockit   apoya este estilo alternativo,   a través de la API verificaciones.

     

JMockit vs Mockito

     

  
• Mockito se basa en las llamadas explícitas a su API con el fin de código separado   entre el registro (cuando (...)) y   verificar (comprobar (...)) fases. Esta   significa que cualquier invocación a una maqueta   objeto en el código de prueba también requerirá   una llamada a la API de burla.   Además, este llevará a menudo a   repetitivo Cuando (...) y   verificar (simulacro) ... llamadas.
  
• Con JMockit, no existen llamadas similares. Claro, tenemos la nueva   NonStrictExpectations (nueva) y   Verificaciones () llamadas de constructor, pero   que ocurren sólo una vez por prueba   (Típicamente), y son completamente   separar de las invocaciones a   métodos burlado y constructores.
  
• El Mockito API contiene varias inconsistencias en la sintaxis utilizada para   invocaciones a métodos burlado. En el   fase de registro, tenemos como llamadas   cuando (mock.mockedMethod (args)), mientras que ...   en la fase de verificar esta misma llamada   se puede escribir como   verificar (simulacros) .mockedMethod (args).   Tenga en cuenta que en el primer caso, el   invocación a mockedMethod se hace   directamente en el objeto simulado, mientras que en   el segundo caso se hace sobre la   objeto devuelto por verificar (mock).
  
• JMockit no tiene tales inconsistencias PORQUE invocaciones a   métodos burlado siempre se hacen   directamente en las instancias burlado   sí mismos. (Con una excepción única:   para que coincida con las invocaciones sobre el mismo   ejemplo burlado, un onInstance (mock)   llamada se utiliza, resultando en código como   onInstance (mock) .mockedMethod (args);   no necesitarán mayoría de las pruebas a utilizar esto,   sin embargo.)
  
• Al igual que otras herramientas burlones que se basan en el método   encadenamiento / envoltura, Mockito también se ejecuta   en sintaxis inconsistente cuando stubbing   métodos vacío. Por ejemplo, se escribe   cuando (mockedList.get (1)). thenThrow (nuevo   Excepción en tiempo de ejecución()); para un no-nula   método, y doThrow (nuevo   RuntimeException ()) cuando (mockedList) .clear ().;   por uno vacío. Con JMockit, es   siempre la misma sintaxis:   mockedList.clear (); Resultado = nuevo   RuntimeException ();.
  
• Sin embargo, otra inconsistencia se produce en el uso de espías Mockito: "burla"   que permiten que los métodos sean reales   ejecutado en la instancia espiado. por   ejemplo, si espía se refiere a un vacío   Lista, a continuación, en lugar de escribir   cuando (spy.get (0)). thenReturn ( "foo") se   tendrá que escribir   doReturn ( "foo"). cuando (espía) .get (0). Con   JMockit, la característica dinámica de burla   proporciona una funcionalidad similar a   espías, pero sin este problema ya   métodos reales solamente se ejecutan durante   la fase de repetición.
  
• En EasyMock y jMock, las API primera burlones para Java, la atención se centró   totalmente en la grabación de espera   invocaciones de métodos burlado, para   objetos simulados que (por defecto) no lo hacen   permitir invocaciones inesperados. Aquellos   Apis también proporcionar la grabación de   invocaciones permitidos para objetos simulados   que sí permiten invocaciones inesperados,   pero esto fue tratada como una segunda clase   característica. Además, con estos   herramientas que no hay manera de forma explícita   verificar invocaciones a burla después de la   código bajo prueba se ejerce. toda esta   verificaciones se realizan de forma implícita   y automáticamente.
  
• En Mockito (y también en Unitils Mock), el punto de vista opuesto es   tomado. Todas las invocaciones a objetos simulados   que pueden ocurrir durante la prueba,   si grabada o no, se les permite,   Nunca se esperaba. La verificación es   realizado de forma explícita después del código   bajo prueba se ejerce, nunca se   automáticamente.
  
• Ambos enfoques son demasiado extremas, y por lo tanto inferior a la óptima.   Las expectativas JMockit y Verificaciones   es la única API que permite la   desarrollador para elegir sin problemas la   mejor combinación de estricta (esperado   por defecto) y no estricto (permitido por   predeterminado) invocaciones simuladas para cada uno   prueba.
  
• Para ser más claro, la API Mockito tiene el siguiente inconveniente. Si tu   debe comprobar que una invocación a una   no nula método burlado sucedió durante   la prueba, pero la prueba requiere una   valor de retorno de que el método que es   diferente de la predeterminada para el   tipo de retorno, entonces la prueba Mockito   tendrá código duplicado: una   cuando (mock.someMethod ()). thenReturn (xyz)   llamar en la fase de registro, y una   verificar (simulacro) .someMethod () en el   verificar fase. Con JMockit, una estricta   expectativa siempre se puede grabar,   que no tendrá que ser explícitamente   verificado. Alternativamente, una invocación   contar restricción (veces = 1) pueden ser   especificado para cualquier grabadas no estricto   expectativa (con Mockito tales   restricciones sólo se pueden especificar en una   verificar (maqueta, restricción) llamada).
  
• Mockito tiene mala sintaxis para las verificaciones en orden, y para la plena   verificaciones (es decir, la comprobación de que   todas las invocaciones a objetos simulados son   verificado explícitamente). En el primero   caso, un objeto adicional tiene que ser   creadas y llamadas para verificar hacen en   que: a finde finde = finde (mock1,   mock2, ...). En el segundo caso, las llamadas   como verifyNoMoreInteractions (mock) o   verifyZeroInteractions (mock1, mock2)   necesidad de hacerse.
  
• Con JMockit, sólo tiene que escribir nuevos VerificationsInOrder () o una nueva   FullVerifications () en lugar de nuevo   Verificaciones () (o nueva   FullVerificationsInOrder () para combinar   ambos requisitos). No hay necesidad de especificar   la cual los objetos de imitación están involucrados. No   llamadas a la API burlones adicionales. Y como   bono, llamando   unverifiedInvocations () dentro de una   bloque de verificación solicitado, puede   realizarverificaciones relacionados con los pedidos   que son simplemente imposible en Mockito.
  

     

Por último, el kit de herramientas de pruebas JMockit   tiene un alcance más amplio y más ambicioso   objetivos que otros kits de herramientas burlones, en   Para proporcionar una completa y   pruebas de desarrollador sofisticada   solución. Una buena API para burlarse, incluso   sin limitaciones artificiales, no es   suficiente para la creación productiva de   pruebas. Un IDE-agnóstico, fácil de usar,   y una herramienta de cobertura de código bien integrada   es también esencial, y eso es lo   Cobertura JMockit tiene como objetivo proporcionar.   Otra pieza de la prueba desarrollador   conjunto de herramientas que se harán más útil   como el conjunto de pruebas crece en tamaño es el   capacidad de pruebas incrementalmente ReRun   después de un cambio localizado a la producción   código; esto también está incluido en el   Cobertura herramienta.

(de acuerdo, la fuente puede ser parcial, pero bueno ...)

Yo diría que ir con JMockit . Es el más fácil de usar, flexible, y obras para casi todos los casos, incluso difíciles y escenarios cuando no se puede controlar a la clase a ensayar (o no se puede romper debido a razones de compatibilidad, etc.).

Mis experiencias con JMockit han sido muy positivos.

Answer 2

He trabajado con tanto Mockito y JMockit, y mi experiencia con ellos es:

• Mockito:

  • burla implícita (-> mejor usabilidad, pero tiene el peligro de no detectar las llamadas a métodos no permitidos que aparecen en la burla)
  • comprobación explícita

• EasyMock:

  • explict burla
  • verificación implícita

• JMockit:

  • soportes tanto

• Además, otros beneficios de JMockit:

  • Si estás burlando de métodos estáticos / constructores, etc (como la extensión de una base de código heredado muy vieja y sin UT), usted tiene dos opciones: 1) Mockito / EasyMock con extensión Powermock o 2) Jmockit
  • incorporado en el informe de cobertura

Yo personalmente prefiero JMockit, que creo que es más versátiles y flexibles, pero requiere un poco de curva de aprendizaje poco más alto. Hay por lo general varias maneras de lograr el mismo efecto de burla, y requiere más cuidado en el diseño de los simulacros.

Answer 3

Yo uso jMockit solamente debido a su reflejo en las bibliotecas Deencapsultation.class. De hecho, me encanta el estilo de Mockito, pero me niego a cambiar mi código y enturbiar mi API solo para un marco limitado de pruebas puede llegar a ella. Y yo soy un fan de probar todo mi código, por lo que un marco que no se puede probar fácilmente los métodos privados no es lo que quiero utilizar.

se dejó influir por este artículo

Después de una (la verdad es grande) la curva de aprendizaje, jMockit es ahora mi principal marco de pruebas de unidad para la burla.

Answer 4

Para facilitar la prueba de nuestra base de código heredado (con una gran cantidad de llamadas a métodos estáticos, etc.), JMockit ha sido muy valiosa. [Enchufe desvergonzado para una href="http://codebase.olsonzoo.com/2010/03/unit-testing-java-code-with-jmockit.html" rel="nofollow"> artículo en mi blog]

Answer 5

Yo personalmente prefiero EasyMock .
La capacidad de desvío entre agradable, normal y controles estrictos burlones es uno en mi característica favorita.