Hispanopedia Wiki
Articulo de referencia

Mockito

{{cite web|url=https://github.com/mockito/mockito/releases|title=Project Releases Overview on GitHub|website=[[GitHub]] |access-date=29 July 2025}} "},"repo":{"wt":"{{URL|https:...

Hispanopedia WikiContenido en espanolLectura gratuita

Mockito es un marco de pruebas de código abierto para Java publicado bajo la licencia MIT . [ 3 ] [ 4 ] El marco permite la creación de objetos dobles de prueba ( objetos mock ) en pruebas unitarias automatizadas con el propósito de desarrollo guiado por pruebas (TDD) o desarrollo guiado por comportamiento (BDD).

El nombre y el logotipo del framework son un juego de palabras con mojitos , un tipo de bebida.

Características

Mockito permite a los desarrolladores verificar el comportamiento del sistema bajo prueba (SUT) sin establecer expectativas de antemano. [ 5 ] Una de las críticas a los objetos simulados es que existe un acoplamiento estrecho entre el código de prueba y el sistema bajo prueba. [ 6 ] Mockito intenta eliminar el patrón de esperar-ejecutar-verificar [ 7 ] eliminando la especificación de expectativas. Mockito también proporciona algunas anotaciones para reducir el código repetitivo . [ 8 ]

Orígenes

Mockito comenzó ampliando la sintaxis y la funcionalidad de EasyMock. [ 9 ] [ 10 ]

Ejemplo

Consideremos este programa "Hola mundo" desacoplado ; podemos realizar pruebas unitarias de algunas de sus partes, utilizando objetos simulados para otras.

paquete org.wikipedia.examples ;import java.io.IOException ;public class HelloApplication { public static interface Greeter { String getGreeting ( String subject ); String getIntroduction ( String actor ); }public static class HelloGreeter implements Greeter { private String hello ; private String segmenter ;public HelloGreeter ( String hello , String segmenter ) { this . hello = hello ; this . segmenter = segmenter ; }public String getGreeting ( String subject ) { return String . format ( "%s %s" , hello , subject ); }public String getIntroduction ( String actor ) { return actor + segmenter ; } }public static interface HelloActable { void sayHello ( String actor , String subject ) throws IOException ; }public static class HelloAction implements HelloActable { private Greeter helloGreeter ; private Appendable helloWriter ;public HelloAction ( Greeter helloGreeter , Appendable helloWriter ) { super ( ) ; this.helloGreeter = helloGreeter ; this.helloWriter = helloWriter ; }​​public void sayHello ( String actor , String subject ) throws IOException { helloWriter . append ( helloGreeter . getIntroduction ( actor )). append ( helloGreeter . getGreeting ( subject )); } }public static void main ( String [] args ) throws IOException { new HelloAction ( new HelloGreeter ( "hello" , ": " ), System . out ). sayHello ( "application" , "world" ); } }

El resultado del lanzamiento de HelloApplication será el siguiente:

Aplicación: Hola mundo

Las pruebas unitarias para el componente HelloActable podrían tener este aspecto:

paquete org.wikipedia.examples ;import static org.mockito.Matchers.any ; import static org.mockito.Matchers.eq ; import static org.mockito.Mockito.mock ; import static org.mockito.Mockito.times ; import static org.mockito.Mockito.verify ; import static org.mockito.Mockito.when ;import org.junit.Before ; import org.junit.Test ;import org.wikipedia.examples.HelloApplication.HelloActable ; import org.wikipedia.examples.HelloApplication.HelloAction ; import org.wikipedia.examples.HelloApplication.Greeter ;public class HelloActionUnitTest { Greeter helloGreeterMock ; Appendable helloWriterMock ; HelloActable helloAction ;@Before public void setUp () { helloGreeterMock = mock ( Greeter . class ); helloWriterMock = mock ( Appendable . class ); helloAction = new HelloAction ( helloGreeterMock , helloWriterMock ); } @Test public void testSayHello () throws Exception { when ( helloWriterMock . append ( any ( String . class ))). thenReturn ( helloWriterMock ); when ( helloGreeterMock . getIntroduction ( eq ( "unitTest" ))). thenReturn ( "unitTest : " ); when ( helloGreeterMock . getGreeting ( eq ( "world" ))). thenReturn ( "hi world" );helloAction.sayHello ( " unitTest" , "world" ) ;verificar ( helloGreeterMock ). obtenerIntroducción ( eq ( "unitTest" )); verificar ( helloGreeterMock ). obtenerSaludo ( eq ( "world" ));verificar ( helloWriterMock , veces ( 2 )). append ( any ( String.class ) ); verificar ( helloWriterMock , veces ( 1 )). append ( eq ( "unitTest: " ) ) ; verificar ( helloWriterMock , veces ( 1 )). append ( eq ( "hi world" )); } }

Utiliza objetos simulados para las interfaces Greeter y Appendable, y asume implícitamente el siguiente caso de uso :

unitTest: hola mundo

El código de prueba de integración para probar HelloActable conectado junto con Greeter podría tener el siguiente aspecto:

paquete org.wikipedia.examples ;import static org.mockito.Matchers.any ; import static org.mockito.Matchers.eq ; import static org.mockito.Mockito.mock ; import static org.mockito.Mockito.times ; import static org.mockito.Mockito.verify ; import static org.mockito.Mockito.when ;import org.junit.Before ; import org.junit.Test ;import org.wikipedia.examples.HelloApplication.HelloActable ; import org.wikipedia.examples.HelloApplication.HelloAction ; import org.wikipedia.examples.HelloApplication.Greeter ; import org.wikipedia.examples.HelloApplication.HelloGreeter ;public class HelloActionIntegrationTest { HelloActable helloAction ; Greeter helloGreeter ; Appendable helloWriterMock ;@Before public void setUp () { helloGreeter = new HelloGreeter ( "bienvenido" , " dice " ); helloWriterMock = mock ( Appendable . class ); helloAction = new HelloAction ( helloGreeter , helloWriterMock ); }@Test public void testSayHello () throws Exception { when ( helloWriterMock . append ( any ( String . class ))). thenReturn ( helloWriterMock );helloAction.sayHello ( "integrationTest" , "universe " ) ;verificar ( helloWriterMock , times ( 2 )). append ( any ( String.class ) ); verificar ( helloWriterMock , times ( 1 )). append ( eq ( "integrationTest dice" )); verificar ( helloWriterMock , times ( 1 )). append ( eq ( "welcome universe" )) ; } }

Utiliza objetos simulados únicamente en lugar de las interfaces Appendable, utiliza las implementaciones reales para otras interfaces (HelloActable y Greeter) y asume implícitamente el siguiente caso de uso:

integrationTest dice bienvenido universo

Como se puede observar en las declaraciones de importación de las clases HelloActionUnitTest y HelloActionIntegrationTest, es necesario colocar algunos archivos JAR de Mockito y JUnit en la ruta de clases para poder compilar y ejecutar las clases de prueba.

Véase también

Referencias

  1. ↑ "Descripción general de las versiones del proyecto en GitHub" . GitHub . Consultado el 29 de julio de 2025 .
  2. ↑ "Licencia · mockito/mockito Wiki · GitHub" . GitHub . Consultado el 30 de agosto de 2019 .
  3. ↑ "Mockito en seis ejemplos sencillos" . 2009. Consultado el 5 de octubre de 2012 .
  4. ↑ " ¿Cuál es el mejor framework de simulación para Java? " . Consultado el 29/12/2010 .
  5. ↑ " Características y motivaciones " . Consultado el 29 de diciembre de 2010 .
  6. ↑ Fowler, Martin (2007). " Los simulacros no son esbozos " . Recuperado el 29 de diciembre de 2010 .
  7. ↑ Faber, Szczepan. " Deseo de muerte " . Consultado el 29 de diciembre de 2010 .
  8. ↑ Kaczanowski, Tomek. "Mockito - Marco de simulación Java de código abierto" . Recuperado el 17 de septiembre de 2013 .
  9. ↑ Faber, Szczepan. "Mockito" . Archivado del original el 29 de marzo de 2010. Consultado el 29 de diciembre de 2010 .
  10. ↑ "Página principal de Mockito" . Consultado el 29 de diciembre de 2010 .
  • Sitio web oficial