Font Size

SCREEN

Profile

Layout

Direction

Menu Style

Cpanel

Aninki Code

Jmock

 JMock es una librería de testeo, para el desarrollo de test y mocks.

+ INFO

Jmock - Crear un test

Lo primero que tenemos que hacer para poder ejecutar los test, es definir un contexto de ejecución de mocks. 

Mockery context = new Mockery();

 Para realizar un mock, es tan sencilla como realizar la llamada de mocks

	final IPersona personaMock = context.mock(IPersona.class);

 A partir de ahí tenemos, generamos una serie de casos que se van a ejecutar (expectations):

                context.checking(new Expectations() {
			{
				oneOf(persona).getApellido();will(returnValue("Aninkinet"));

			}
		});

	


Veamos un ejemplo de ejecución de un test:

        @Test
	public void testMock() {

		context.assertIsSatisfied();
		final IPersona persona = context.mock(IPersona.class);

		context.checking(new Expectations() {
			{
				oneOf(persona).getApellido();
				will(returnValue("Aninkinet"));

			}
		});
		log.info(persona.getApellido());

	}


Jmock - Definir cuando ejecutar un mock

Podemos definir cuando queremos ejecutar un test. Podemos definir cuando queremos ejecutar un mock.

Cuando son objetos son iguales:

oneOf (mock).doSomething(with(eq(1)), with(any(String.class)));
....
oneOf(personaMock).getApellido(with(equal("funciona")));

Cuando contienen un string. En el siguiente caso cuando llamados al método getApellido y el método de entrada contiene un String y contiene un string. Se puede introducir tantas condiciones como consideremos necesarias:

oneOf(personaMock).getApellido((with(anyOf(containsString("Marcelo"),containsString("celox")))));

Podemos solicitar que será se ejecute cuando sea exactamente el mismo objeto:

oneOf(personaMock).getApellido(with(same("funciona")));

Tambien podenos ejecutarlo cuando los parametros de entrada sean nulos o no nulos:

              // valor null
             oneOf(personaMock).getApellido(with(aNull(String.class)));will(returnValue(null));
	     // valor no null
	     oneOf(personaMock).getApellido(with(aNonNull(String.class)));will(returnValue("retorno2"));

También podemos definir si queremos que las llamadas del mock sean obligatorias o no:

exactly(n).ofSe tiene que ejecutar n vecesatLeast(n).ofSe tiene que ejecutar por lo menos n vecesatMost(n).ofSe tiene que ejecutar como mucho n vecesbetween(min, max).ofSe tiene que ejecutar por lo menos min veces y como mucho max vecesallowingSe puede ejecutar n veces, pero no es necesari que se ejecute alguna vez

one Se tiene que ejecutar una y solo una vez

Cabe destacar que si no se cumplen estas condiciones, el test resultará en error. Como ejemplo:  

		                // Oneof ---se tiene que llamar siempre, si o si en el test
				oneOf(personaMock).getApellido(with(equal("funciona")));
				will(returnValue("retorno2"));
				// Allowing-- puede llamarse o no. Si no se llama, no da error
				allowing(personaMock).getApellido(with(equal("no funciona")));
				will(returnValue("retorno2"));
				// por lo menos una vez
				atLeast(1).of(personaMock).getApellido(with(equal("texto")));
				will(returnValue("retorno2"));
				// Como mucho 2 veces
				atMost(2).of(personaMock).getApellido(with(equal("texto")));
				will(returnValue("retorno2"));
				// espero entre 1 y tres veces.
				between(1, 3).of(personaMock)
						.getApellido(with(equal("texto3")));
				will(returnValue("retorno2"));

				ignoring(personaMock2);

	


Jmock - Definir resultados esperados

Podemos definir qué acciones ejecutar cuando se cumpla algunso de los resultados esperados de un mock

Devolver un valor

will(returnValue("Aninkinet"));

Devoler una excepcion

	will(throwException(new NullPointerException()));

Podemos crear una acción propia. En ese caso será necesario crear un objeto factoria de acceso y una clase implementadora que heredará de la interface org.jmock.api.Action.

	@Test
	public void testCustomActors() {
		final IPersona personaMock = context.mock(IPersona.class);
		
		context.checking(new Expectations() {
			{
				IPersona ipersona=new Persona();
				
				oneOf(personaMock).getApellido(with(ApellidoNulo.esApellidoNulo("a")));will(CreateFileFactory.createFile("nombreFichero"));
			

			}
		});

		public class CreateFileFactory {

			public static  Action createFile(T... newElements) {
			    return new CreateFile(Arrays.asList(newElements));
			}

		}

		public class CreateFile implements Action{

		private Collection elements;
    
		    public CreateFile(Collection elementss) {
		        this.elements = elementss;
		    }
    
		    public void describeTo(Description description) {
		        description.appendText("adds ")
 		                  .appendValueList("", ", ", "", elements)
		                   .appendText(" to a collection");
  		  }
    
 		   public Object invoke(Invocation invocation) throws Throwable {
 		   	System.out.println("parametro"+invocation.getParametersAsArray());
   		 	System.out.println("parametro 1 :"+invocation.getParameter(0));
  		    // ((Collection)invocation.getParameter(0)).addAll(elements);
        
  		      return "fichero creado";
  		  }

		}
 

jmock - Ejemplo completo

package com.aninki.jmock;

import static org.hamcrest.Matchers.anyOf;
import static org.hamcrest.Matchers.containsString;

import java.util.List;

import junit.framework.TestCase;

import org.jmock.Expectations;
import org.jmock.Mockery;
import org.jmock.integration.junit4.JMock;
import org.junit.Test;
import org.junit.runner.RunWith;

import com.aninki.jmock.actors.CreateFileFactory;
import com.aninki.jmock.machers.ApellidoNulo;
import com.aninki.net.jmock.vo.IPersona;
import com.aninki.net.jmock.vo.IPersonaIgnorable;
import com.aninki.net.jmock.vo.Persona;

@RunWith(JMock.class)
public class Test1 extends TestCase {
	// define our test fixture class and create a "Mockery" that represents the
	// context in which the Publisher exists

	Mockery context = new Mockery();

	@Test//
	public void testMock() {

		context.assertIsSatisfied();
		final IPersona persona = context.mock(IPersona.class);

		// las respuestas se guardan en algo llamado expentations
		context.checking(new Expectations() {
			{
				// devuelve un valor
				oneOf(persona).getApellido();
				will(returnValue("Aninkinet"));

			}
		});
		// Expectations do not have to be defined in the body of the test
		// method. You can define expectations in helper methods or the setUp
		// method to remove duplication or clarify the test code.
		System.out.println(persona.getApellido());

	}

	@Test
	public void tetMockReturnValues() {

		// /////////////////////////
		final IPersona personaMock = context.mock(IPersona.class);
		context.checking(new Expectations() {
			{

				oneOf(personaMock).getApellido();will(returnValue("Alejandro"));
				// si ponemos más de una devuelve más de un valor. En la segunda
				// llamad será marcos.
				oneOf(personaMock).getApellido();
				will(returnValue("Marcos"));
			}
		});

		System.out.println(personaMock.getApellido());
		System.out.println(personaMock.getApellido());
		// ////////////////////////

		final List listapersonaMock = context.mock(java.util.List.class);

	}

	@Test
	public void tetThrowExceptions() {

		// /////////////////////////
		final IPersona personaMock = context.mock(IPersona.class);
		context.checking(new Expectations() {
			{

				oneOf(personaMock).getApellido();
				will(throwException(new NullPointerException()));

			}
		});

		try {
			System.out.println(personaMock.getApellido());
		} catch (NullPointerException e) {
			System.out.println("lanzo nullpointer a proposito");

		}

	}

	@Test
	public void testMaching() {

		// /////////////////////////
		final IPersona personaMock = context.mock(IPersona.class);
		context.checking(new Expectations() {
			{
				oneOf(personaMock).getApellido(null);
				will(throwException(new NullPointerException()));
				oneOf(personaMock).getApellido("Marcos");
				will(returnValue("retorno1"));
			}
		});
		// no importa el orden en que he definod las declaraciones.
		System.out.println(personaMock.getApellido("Marcos"));
		try {
			System.out.println(personaMock.getApellido(null));
		} catch (NullPointerException e) {
			System.out.println("lanzo nullpointer a proposito");
		}

	}

	@Test
	public void testMachers() {
		final IPersona personaMock = context.mock(IPersona.class);
		context.checking(new Expectations() {
			{
				// podemos utilizar algunos funciones, como equals
				oneOf(personaMock).getApellido(with(equal("Marcos")));
				will(returnValue("retorno2"));
				// contien un estrng
				oneOf(personaMock).getApellido(
						(with(anyOf(containsString("Marcelo"),
								containsString("celox")))));
				will(returnValue("retorno2"));

			}
		});
		System.out.println(("---"));
		System.out.println(personaMock.getApellido("Marcos"));
		System.out.println(personaMock.getApellido("Marcelo11"));

	}

	@Test//
	public void testBasicMachers() {
		final IPersona personaMock = context.mock(IPersona.class);
		context.checking(new Expectations() {
			{
				// The most commonly used matcher is equal, which specifies that
				// the received argument must be equal to a given value
				oneOf(personaMock).getApellido(with(equal("funciona")));
				will(returnValue("retorno2"));
				// The same matcher specifies that the actual value of the
				// argument must be the same object as the expected value
				oneOf(personaMock).getApellido(with(same("funciona")));
				will(returnValue("retorno2"));
				// valor null
				oneOf(personaMock).getApellido(with(aNull(String.class)));
				will(returnValue(null));
				// valor no null
				oneOf(personaMock).getApellido(with(aNonNull(String.class)));
				will(returnValue("retorno2"));
				// con cualquier valor
				oneOf(personaMock).getApellido(with(any(String.class)));
				will(returnValue("retorno2"));

			}
		});
		System.out.println(("-testBasicMachers--"));
		System.out.println(personaMock.getApellido("funciona"));
		// el string funciona porque es instancia unica
		System.out.println(personaMock.getApellido("funciona"));

		System.out.println(personaMock.getApellido(null));

		System.out.println(personaMock.getApellido("funciona"));
		//
		System.out.println(personaMock.getApellido("funciona"));
		// estos machers se pueden utilizar aunque haya más de una función

	}

	@Test
	public void testCardinalidad() {

		// The "invocation count" of an expectation defines the minimum and
		// maximum number of times that the expected method is allowed to be
		// invoke
		final IPersona personaMock = context.mock(IPersona.class);
		final IPersonaIgnorable personaMock2 = context
				.mock(IPersonaIgnorable.class);

		context.checking(new Expectations() {
			{
				// Oneof ---se tiene que llamar siempre, si o si en el test
				oneOf(personaMock).getApellido(with(equal("funciona")));
				will(returnValue("retorno2"));
				// Allowing-- puede llamarse o no. Si no se llama, no da error
				allowing(personaMock).getApellido(with(equal("no funciona")));
				will(returnValue("retorno2"));
				// por lo menos una vez
				atLeast(1).of(personaMock).getApellido(with(equal("texto")));
				will(returnValue("retorno2"));
				// Como mucho 2 veces
				atMost(2).of(personaMock).getApellido(with(equal("texto")));
				will(returnValue("retorno2"));
				// espero entre 1 y tres veces.
				between(1, 3).of(personaMock)
						.getApellido(with(equal("texto3")));
				will(returnValue("retorno2"));

				ignoring(personaMock2);

			}
		});
		System.out.println(("-testCardinalidad--"));
		System.out.println(personaMock.getApellido("funciona"));

		//
		System.out.println(personaMock.getApellido("texto"));

		System.out.println(personaMock.getApellido("texto3"));
		System.out.println(personaMock.getApellido("texto3"));

		// ignora los retorno de este objeto
		/*
		 * Return Type "Zero" Value boolean false numeric type zero String ""
		 * (empty string) Array Empty array Mockable type A mock that is ignored
		 * Any other type null
		 */
		System.out.println("--" + personaMock2.getApellido("ape"));

	}

	
	//
	@Test
	public void testCustomMacher() {
		final IPersona personaMock = context.mock(IPersona.class);
		
		context.checking(new Expectations() {
			{
				IPersona ipersona=new Persona();
				
				oneOf(personaMock).getApellido(with(ApellidoNulo.esApellidoNulo("a")));will(returnValue("retorno2"));
				oneOf(personaMock).getApellido(with(ApellidoNulo.esApellidoNulo(null)));will(returnValue("retorno100"));

			}
		});
		//explicar apellido nulo y EsApellidonulomacher
		
		System.out.println(("-testCustomMacher--"));
		System.out.println(personaMock.getApellido("Marcos200"));
		System.out.println(personaMock.getApellido("otra mas"));
	

	}
	
	@Test
	public void testCustomActors() {
		final IPersona personaMock = context.mock(IPersona.class);
		
		context.checking(new Expectations() {
			{
				IPersona ipersona=new Persona();
				
				oneOf(personaMock).getApellido(with(ApellidoNulo.esApellidoNulo("a")));will(CreateFileFactory.createFile("nombreFichero"));
			

			}
		});
		//explicar apellido nulo y EsApellidonulomacher
		
		System.out.println(("-testCustomActors--"));
		System.out.println(personaMock.getApellido("Marcos200"));
		
	

	}
	
	
	

}