Wykonywanie fałszywej metody zwraca argument, który został do niej przekazany

Rozważ podpis metody, taki jak:

public String myFunction(String abc);

Czy Mockito może pomóc zwrócić ten sam ciąg znaków, który otrzymała metoda?

Możesz utworzyć odpowiedź w Mockito. Załóżmy, że mamy interfejs o nazwie Aplikacja z metodą myFunction.

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

Oto metoda testowa z odpowiedzią 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"));
}

Od wersji Mockito 1.9.5 i Java 8 można również użyć wyrażenia lambda:

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

Jeśli masz Mockito w wersji 1.9.5 lub nowszej, istnieje nowa metoda statyczna, która może uczynić Answerobiekt dla Ciebie. Musisz napisać coś takiego

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

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

lub alternatywnie

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

Zauważ, że returnsFirstArg()metoda jest statyczna w AdditionalAnswersklasie, co jest nowością w Mockito 1.9.5; więc potrzebujesz odpowiedniego importu statycznego.

W Javie 8 możliwe jest utworzenie odpowiedzi w jednym wierszu, nawet w przypadku starszej wersji Mockito:

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

Oczywiście nie jest to tak przydatne, jak użycie AdditionalAnswerssugerowane przez Davida Wallace'a, ale może być przydatne, jeśli chcesz przekształcić argument „w locie”.

Miałem bardzo podobny problem. Celem było wykpienie usługi, która utrwala Obiekty i może zwrócić je po nazwie. Usługa wygląda następująco:

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

Makieta usługi używa mapy do przechowywania instancji pokoju.

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

Możemy teraz uruchomić nasze testy na tej makiecie. Na przykład:

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

W Javie 8 odpowiedź Steve'a może się stać

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

EDYCJA: Jeszcze krótsza:

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

To dość stare pytanie, ale myślę, że nadal jest aktualne. Również zaakceptowana odpowiedź działa tylko dla String. Tymczasem jest Mockito 2.1 i niektóre importy uległy zmianie, dlatego chciałbym podzielić się moją obecną odpowiedzią:

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

Funkcja myClass.myF wygląda następująco:

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

Używam czegoś podobnego (w zasadzie jest to to samo podejście). Czasami przydatne jest, aby sztuczny obiekt zwracał wstępnie zdefiniowane dane wyjściowe dla niektórych danych wejściowych. To wygląda tak:

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

Możesz użyć Verify () w połączeniu z ArgumentCaptor, aby zapewnić wykonanie testu i ArgumentCaptor do oceny argumentów:

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

Wartość argumentu jest oczywiście dostępna poprzez argument.getValue () w celu dalszej manipulacji / sprawdzania / czegokolwiek.

To jest trochę stare, ale przyszedłem tutaj, ponieważ miałem ten sam problem. Używam JUnit, ale tym razem w aplikacji Kotlin z mockk. Zamieszczam tutaj próbkę w celach informacyjnych i porównawczych z odpowiednikiem 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"))
}

Możesz to osiągnąć za pomocą ArgumentCaptor

Wyobraź sobie, że masz taką funkcję fasoli.

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

Następnie w klasie testowej:

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

LUB jeśli jesteś fanem lambda, po prostu wykonaj:

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


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

Podsumowanie: Użyj argumentcaptor, aby przechwycić przekazany parametr. Później w odpowiedzi zwraca wartość przechwyconą za pomocą getValue.