Mockテスト

Mockito

https://code.google.com/p/mockito/

<dependency>

<groupId>org.mockito</groupId>

<artifactId>mockito-all</artifactId>

<version>1.9.5</version>

<scope>test</scope>

</dependency>

基本的な使い方

public class MyService {

public String method() {

return "xxx";

}

public String anotherMethod() {

return method() + "," + method();

}

}

import static org.mockito.Mockito.*;

public class MyServiceTest {

@Test

public void testMock() {

// クラスごと（対象クラスの実装に依存せず）

MyService myService = mock(MyService.class);

when(myService.method()).thenReturn("xxx");

String actual = myService.method();

assertEquals(actual, "xxx");

// 特定のメソッドのみ（対象クラスの実装に依存）

MyService myService = spy(new MyService());

when(myService.method()).thenReturn("xxx");

String actual = myService.anotherMethod();

assertEquals(actual, "yyy");

}

}

サンプル

public class SampleA {

private SampleB sampleB;

private SampleC sampleC;

public String createName() {

return sampleB.getName("xxx");

}

public String createPrice() {

int id = sampleC.getId();

int price = sampleC.getPrice(id);

return "id:" + id + " price:" + price;

}

}

import static org.mockito.Matchers.*;

import static org.mockito.Mockito.*;

import static org.hamcrest.Matchers.*;

public class SampleTest {

@Mock

private SampleB sampleBMock;

@Spy

private SampleC sampleCMock = new SampleC();

@InjectMocks //テスト対象

private SampleA sampleA = new SampleAImpl();

@InjectMocks //複数の@InjectMocksが使える；フィールドもMockできる

@Spy

private SampleD sampleD = new SampleDImpl();

※@InjectMocksと@Spyは一緒に使えるが、@InjectMocksと@Mockは×

@Before

public void setup() {

MockitoAnnotations.initMocks(this);

}

@Test

public void testVerifyMock() {

when(sampleBMock.get(0)).thenReturn("first");

when(sampleBMock.get(1)).thenThrow(new RuntimeException());

when(sampleBMock.getName(anyString())).thenReturn("mock");

//連続

when(sampleBMock.someMethod("xxx"))

.thenThrow(new RuntimeException())

.thenReturn("foo");

when(sampleBMock.someMethod("xxx"))

.thenReturn("one", "two", "three");

String ret = sampleA.createName();

assertEquals("mock", ret);

verify(sampleBMock, times(1)).getName("xxx");

verify(sampleBMock).getName("xxx"); // times(1)はデフォルト

verify(sampleBMock, never()).getName("never");

verify(sampleBMock, atLeastOnce()).add("three times");

verify(sampleBMock, atLeast(2)).add("five times");

verify(sampleBMock, atMost(5)).add("three times");

verify(sampleBMock).get(anyInt());

verify(sampleBMock).someMethod(

anyInt(), anyString(), eq("third argument"));

verify(sampleBMock, timeout(100)).someMethod();

verify(sampleBMock, timeout(100).times(2)).someMethod();

// voidメソッドのスタブ化

doThrow(new RuntimeException()).when(sampleBMock).clear();

doNothing()

.doThrow(new RuntimeException())

.when(sampleBMock).someVoidMethod();

//上書きの場合

when(sampleBMock.foo()).thenThrow(new RuntimeException());

// when(sampleBMock.foo()).thenReturn("bar"); //×

doReturn("bar").when(sampleBMock).foo();

}

@Test

public void testVerifySpy() {

doReturn(100).when(sampleCMock).getPrice(anyInt());

String ret = sampleA.createPrice();

assertEquals("id:2 price:100", ret);

when(sampleCMock.size()).thenReturn(100);

List list = new LinkedList();

List spy = spy(list);

//when(spy.get(0)).thenReturn("foo"); //例外

doReturn("foo").when(spy).get(0);

assertThat(list.get(0), is("foo"));

}

}

※後置記法と前置記法（NOTE：戻り値がvoidのメソッドは前置記法で）

when(mock.get(0)).thenReturn("xxx");

when(mock.get(1)).thenThrow(new IndexOutOfBoundsException());

doReturn("xxx").when(mock).get(0);

doThrow(new IndexOutOfBoundsException()).when(mock).get(1);

★ArgumentCaptor用法

基本

@Mock

private List mock;

@Captor

private ArgumentCaptor<MyClass> captor;

mock.add(new MyClass("foo"));

//verify(mock).add(new MyClass("foo"));

verify(mock).add(captor.capture());

MyClass argument = captor.getValue();

assertEquals("foo", argument.getName());

サンプル

public class PersonService{

@Inject

private PersonDao personDao;

public boolean update(Integer personId, String name){

Person person = personDao.findPerson(personId);

if(person != null){

Person updatedPerson =

new Person(person.getPersonID(), name);

personDao.update(updatedPerson);

return true;

}

return false;

}

}

import static org.junit.Assert.*;

import org.mockito.ArgumentCaptor;

import org.mockito.Mock;

import org.mockito.InjectMocks;

import org.mockito.MockitoAnnotations;

public class PersonServiceTest{

@Mock

private PersonDao personDAO;

@InjectMocks

private PersonService personService;

@Captor

private ArgumentCaptor<Person> personCaptor;

@Before

public void setUp() throws Exception{

MockitoAnnotations.initMocks(this);

}

@Test

public void shouldUpdatePersonName(){

Person person = new Person(101, "xxx");

when(personDAO.findPerson(101)).thenReturn(person);

boolean updated = personService.update(101, "yyy");

assertTrue(updated);

verify(personDAO).findPerson(101);

verify(personDAO).update(personCaptor.capture());

Person updatedPerson = personCaptor.getValue();

assertEquals("yyy", updatedPerson.getPersonName());

verifyNoMoreInteractions(personDAO);

}

@Test

public void shouldNotUpdateIfPersonNotFound(){

when(personDAO.findPerson(101)).thenReturn(null);

boolean updated = personService.update(101, "yyy");

assertFalse(updated);

verify(personDAO).findPerson(101);

verifyZeroInteractions(personDAO);

verifyNoMoreInteractions(personDAO);

}

}

★Answer用法

サンプル１

@Spy

private Logger logger;

final StringBuilder sb = new StringBuilder();

doAnswer(new Answer<Void>() {

@Override

public Void answer(InvocationOnMock invocation) throws Throwable {

sb.append(invocation.getArguments()[0]);

invocation.callRealMethod();

return null;

}

}).when(logger).info(anyString());

assertThat(sb.toString(), is("xxx"));

サンプル２

@Mock

private Sample mock;

doAnswer(new Answer<Object>() {

@Override

public Object answer(InvocationOnMock invocation) throws Throwable {

theString = (String) invocation.getArguments()[0];

return null;

}

}).when(mock).setString(anyString());

when(mock.getString()).thenAnswer(new Answer<String>() {

@Override

public String answer(InvocationOnMock invocation) throws Throwable {

return theString;

}

});

mock.setString("foo");

assertEquals("foo", mock.getString());

サンプル３

@Inject

private PersonJobDao personJobDao;

public PersonJob createPersonJob(Person person, Job job) {

...

PersonJob personJob = new PersonJob(person, job);

return personJobDao.create(personJob);

}

@Mock

private PersonJobDao personJobDao;

@Test

public void shouldXxx() {

when(personJobDao.create(any(PersonJob.class)))

.thenAnswer(new Answer<PersonJob>() {

public PersonJob answer(InvocationOnMock invocation)

throws Throwable {

return (PersonJob) invocation.getArguments()[0];

}

});

Person person = new Person();

Job job = new Job();

PersonJob personJob = personJobManager.createPersonJob(person, job);

assertThat(personJob.getPerson(), is(person));

assertThat(personJob.getJob(), is(job));

}