Направете подиграван метод да върне аргумент, който му е бил предаден

Можете да създадете отговор в Mockito. Да приемем, че имаме интерфейс с име Приложение с метод myFunction.

public interface Application {
  public String myFunction(String abc);
}

Ето тестовия метод с отговор на Mockito:

public void testMyFunction() throws Exception {
  Application mock = mock(Application.class);
  when(mock.myFunction(anyString())).thenAnswer(new Answer<String>() {
    @Override
    public String answer(InvocationOnMock invocation) throws Throwable {
      Object[] args = invocation.getArguments();
      return (String) args[0];
    }
  });

  assertEquals("someString",mock.myFunction("someString"));
  assertEquals("anotherString",mock.myFunction("anotherString"));
}

От Mockito 1.9.5 и Java 8 можете също да използвате ламбда израз:

when(myMock.myFunction(anyString())).thenAnswer(i -> i.getArguments()[0]);

Ако имате Mockito 1.9.5 или по-нова версия, има нов статичен метод, който може да направи обекта Answer вместо вас. Трябва да напишете нещо подобно

import static org.mockito.Mockito.when;
import static org.mockito.AdditionalAnswers.returnsFirstArg;

when(myMock.myFunction(anyString())).then(returnsFirstArg());

или алтернативно

doAnswer(returnsFirstArg()).when(myMock).myFunction(anyString());

Имайте предвид, че методът returnsFirstArg() е статичен в класа AdditionalAnswers, който е нов за Mockito 1.9.5; така че ще ви е необходим правилният статичен импорт.

С Java 8 е възможно да се създаде отговор от един ред дори с по-стара версия на Mockito:

when(myMock.myFunction(anyString()).then(i -> i.getArgumentAt(0, String.class));

Разбира се, това не е толкова полезно, колкото използването на AdditionalAnswers, предложено от Дейвид Уолъс, но може да бъде полезно, ако искате да трансформирате аргумента "в движение".

Имах много подобен проблем. Целта беше да се подиграе с услуга, която запазва обекти и може да ги върне по името им. Услугата изглежда така:

public class RoomService {
    public Room findByName(String roomName) {...}
    public void persist(Room room) {...}
}

Макетът на услугата използва карта за съхраняване на екземплярите на стаята.

RoomService roomService = mock(RoomService.class);
final Map<String, Room> roomMap = new HashMap<String, Room>();

// mock for method persist
doAnswer(new Answer<Void>() {
    @Override
    public Void answer(InvocationOnMock invocation) throws Throwable {
        Object[] arguments = invocation.getArguments();
        if (arguments != null && arguments.length > 0 && arguments[0] != null) {
            Room room = (Room) arguments[0];
            roomMap.put(room.getName(), room);
        }
        return null;
    }
}).when(roomService).persist(any(Room.class));

// mock for method findByName
when(roomService.findByName(anyString())).thenAnswer(new Answer<Room>() {
    @Override
    public Room answer(InvocationOnMock invocation) throws Throwable {
        Object[] arguments = invocation.getArguments();
        if (arguments != null && arguments.length > 0 && arguments[0] != null) {
            String key = (String) arguments[0];
            if (roomMap.containsKey(key)) {
                return roomMap.get(key);
            }
        }
        return null;
    }
});

Вече можем да проведем нашите тестове на този макет. Например:

String name = "room";
Room room = new Room(name);
roomService.persist(room);
assertThat(roomService.findByName(name), equalTo(room));
assertNull(roomService.findByName("none"));

С Java 8 отговорът на Стив може да стане

public void testMyFunction() throws Exception {
    Application mock = mock(Application.class);
    when(mock.myFunction(anyString())).thenAnswer(
    invocation -> {
        Object[] args = invocation.getArguments();
        return args[0];
    });

    assertEquals("someString", mock.myFunction("someString"));
    assertEquals("anotherString", mock.myFunction("anotherString"));
}

РЕДАКТИРАНЕ: Още по-кратко:

public void testMyFunction() throws Exception {
    Application mock = mock(Application.class);
    when(mock.myFunction(anyString())).thenAnswer(
        invocation -> invocation.getArgument(0));

    assertEquals("someString", mock.myFunction("someString"));
    assertEquals("anotherString", mock.myFunction("anotherString"));
}

Това е доста стар въпрос, но мисля, че все още е актуален. Също така приетият отговор работи само за String. Междувременно има Mockito 2.1 и някои импортирания са променени, така че бих искал да споделя текущия си отговор:

import static org.mockito.AdditionalAnswers.returnsFirstArg;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;

@Mock
private MyClass myClass;

// this will return anything you pass, but it's pretty unrealistic
when(myClass.myFunction(any())).then(returnsFirstArg());
// it is more "life-like" to accept only the right type
when(myClass.myFunction(any(ClassOfArgument.class))).then(returnsFirstArg());

myClass.myFunction ще изглежда така:

public class MyClass {
    public ClassOfArgument myFunction(ClassOfArgument argument){
        return argument;
    }  
}

Това е малко старо, но дойдох тук, защото имах същия проблем. Използвам JUnit, но този път в приложение на Kotlin с mockk. Публикувам пример тук за справка и сравнение с аналога на Java:

@Test
fun demo() {
  // mock a sample function
  val aMock: (String) -> (String) = mockk()

  // make it return the same as the argument on every invocation
  every {
    aMock.invoke(any())
  } answers {
    firstArg()
  }

  // test it
  assertEquals("senko", aMock.invoke("senko"))
  assertEquals("senko1", aMock.invoke("senko1"))
  assertNotEquals("not a senko", aMock.invoke("senko"))
}

Можете да постигнете това, като използвате ArgumentCaptor

Представете си, че имате такава функция.

public interface Application {
  public String myFunction(String abc);
}

След това във вашия тестов клас:

//Use ArgumentCaptor to capture the value
ArgumentCaptor<String> param = ArgumentCaptor.forClass(String.class);


when(mock.myFunction(param.capture())).thenAnswer(new Answer<String>() {
    @Override
    public String answer(InvocationOnMock invocation) throws Throwable {
      return param.getValue();//return the captured value.
    }
  });

ИЛИ ако сте фен на ламбда просто направете:

//Use ArgumentCaptor to capture the value
ArgumentCaptor<String> param = ArgumentCaptor.forClass(String.class);


when(mock.myFunction(param.capture()))
    .thenAnswer((invocation) -> param.getValue());

Резюме: Използвайте argumentcaptor, за да заснемете предадения параметър. По-късно в отговор връща стойността, уловена с getValue.

Може да искате да използвате verify() в комбинация с ArgumentCaptor, за да осигурите изпълнение на теста и ArgumentCaptor, за да оцените аргументите:

ArgumentCaptor<String> argument = ArgumentCaptor.forClass(String.class);
verify(mock).myFunction(argument.capture());
assertEquals("the expected value here", argument.getValue());

Стойността на аргумента очевидно е достъпна чрез argument.getValue() за по-нататъшно манипулиране / проверка / каквото и да е.

Използвам нещо подобно (по принцип това е същият подход). Понякога е полезно макетният обект да връща предварително дефиниран изход за определени входове. Това става така:

private Hashtable<InputObject,  OutputObject> table = new Hashtable<InputObject, OutputObject>();
table.put(input1, ouput1);
table.put(input2, ouput2);

...

when(mockObject.method(any(InputObject.class))).thenAnswer(
       new Answer<OutputObject>()
       {
           @Override
           public OutputObject answer(final InvocationOnMock invocation) throws Throwable
           {
               InputObject input = (InputObject) invocation.getArguments()[0];
               if (table.containsKey(input))
               {
                   return table.get(input);
               }
               else
               {
                   return null; // alternatively, you could throw an exception
               }
           }
       }
       );