Fare un metodo deriso restituisce un argomento che gli è stato passato

Prendi in considerazione una firma del metodo come:

public String myFunction(String abc);

Mockito può aiutare a restituire la stessa stringa ricevuta dal metodo?

Puoi creare una risposta in Mockito. Supponiamo che abbiamo un'interfaccia denominata Applicazione con un metodo myFunction.

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

Ecco il metodo di prova con una risposta 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"));
}

Da Mockito 1.9.5 e Java 8, puoi anche usare un'espressione lambda:

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

Se hai Mockito 1.9.5 o versioni successive, esiste un nuovo metodo statico che può creare l' Answeroggetto per te. Devi scrivere qualcosa del genere

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

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

o in alternativa

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

Si noti che il returnsFirstArg()metodo è statico nella AdditionalAnswersclasse, che è nuovo in Mockito 1.9.5; quindi avrai bisogno della giusta importazione statica.

Con Java 8 è possibile creare una risposta di una riga anche con la versione precedente di Mockito:

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

Naturalmente questo non è utile come l'uso AdditionalAnswerssuggerito da David Wallace, ma potrebbe essere utile se si desidera trasformare l'argomento "al volo".

Ho avuto un problema molto simile. L'obiettivo era quello di deridere un servizio che persiste gli oggetti e può restituirli con il loro nome. Il servizio è simile al seguente:

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

Il servizio mock utilizza una mappa per memorizzare le istanze di 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;
    }
});

Ora possiamo eseguire i nostri test su questo finto. Per esempio:

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

Con Java 8, la risposta di Steve può diventare

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"));
}

EDIT: Ancora più breve:

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"));
}

Questa è una domanda piuttosto vecchia ma ritengo sia ancora pertinente. Anche la risposta accettata funziona solo per String. Nel frattempo c'è Mockito 2.1 e alcune importazioni sono cambiate, quindi vorrei condividere la mia risposta attuale:

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 sarebbe simile a:

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

Uso qualcosa di simile (sostanzialmente è lo stesso approccio). A volte è utile che un oggetto simulato restituisca un output predefinito per determinati input. Va così:

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
               }
           }
       }
       );

È possibile che si desideri utilizzare verify () in combinazione con ArgumentCaptor per assicurare l'esecuzione nel test e ArgumentCaptor per valutare gli argomenti:

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

Il valore dell'argomento è ovviamente accessibile tramite argomento.getValue () per ulteriori manipolazioni / controlli / qualunque cosa.

Questo è un po 'vecchio, ma sono venuto qui perché avevo lo stesso problema. Sto usando JUnit ma questa volta in un'app Kotlin con mockk. Sto pubblicando un campione qui per riferimento e confronto con la controparte 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"))
}

È possibile ottenere ciò utilizzando ArgumentCaptor

Immagina di avere la funzione bean in questo modo.

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

Quindi nella tua classe di test:

//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.
    }
  });

O se sei un fan di Lambda, semplicemente:

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


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

Riepilogo: utilizzare argomentocaptor per acquisire il parametro passato. Successivamente nella risposta restituisce il valore acquisito usando getValue.