Menu

Różne typy dopasowań zapewniane przez Mockito

  • Główny
  • Inny
  • Różne typy dopasowań zapewniane przez Mockito

different types matchers provided mockito

jak otworzyć plik mkv w systemie windows

Wypróbuj Nasz Instrument Do Eliminowania Problemów

Wprowadzenie do różnych typów dopasowań w Mockito.

Mocks and Spies w Mockito zostały szczegółowo wyjaśnione w naszym poprzednim samouczku o szczegółach Seria szkoleń Mockito .

Co to są dopasowani?

Dopasowania są podobne do wyrażeń regularnych lub symboli wieloznacznych, w których zamiast określonego wejścia (i / lub wyjścia) określa się zakres / typ wejścia / wyjścia na podstawie tego, które kody pośredniczące / szpiegów mogą być spoczynkowe, a wywołania do kodów pośredniczących można weryfikować.

Wszystkie dopasowania Mockito są częścią „ Mockito ” klasa statyczna.

Dopasowania to potężne narzędzie, które umożliwia skróconą metodę konfigurowania kodów pośredniczących, a także weryfikację wywołań na kodach pośredniczących, wymieniając argumenty wejściowe jako typy ogólne dla określonych wartości w zależności od przypadku użycia lub scenariusza.

Różne typy dopasowań zapewniane przez Mockito

Czego się nauczysz:

Rodzaje dopasowań w Mockito

W Mockito istnieją zasadniczo 2 typy dopasowań lub pod względem użytkowania, dopasowania mogą być używane dla poniższych 2 kategorii:

  1. Dopasowywanie argumentów podczas konfiguracji kodu
  2. Weryfikacja dopasowująca do weryfikacji rzeczywistych wywołań kodów pośredniczących

W przypadku obu typów dopasowań, tj. Argumentów i weryfikacji, Mockito zapewnia ogromny zestaw dopasowań (Click tutaj aby uzyskać pełną listę dopasowań).

Dopasowywanie argumentów

Wymienione są najczęściej używane:

W przypadku wszystkich poniższych rozważmy przetestowanie IntegerList:

final List mockedIntList = mock(ArrayList.class);

# 1) any () - akceptuje dowolny obiekt (w tym null).

when (mockedIntList.get( any ())).thenReturn(3);

#dwa) dowolna (klasa języka java) -

Przykład : any (ClassUnderTest.class) - jest to bardziej szczegółowy wariant any () i akceptuje tylko obiekty typu klasy, który jest wymieniony jako parametr szablonu.

when (mockedIntList.get( any (Integer.class))).thenReturn(3);

# 3) anyBoolean (), anyByte (), anyInt (), anyString (), anyDouble (), anyFloat (), anyList () i wiele innych - wszystkie akceptują dowolny obiekt odpowiedniego typu danych, a także wartości null.

when (mockedIntList.get( any Int())).thenReturn(3);

# 4) Specyficzne argumenty - w przypadkach, gdy rzeczywiste argumenty są znane z góry, zawsze zaleca się ich użycie, ponieważ zapewniają one większą pewność w porównaniu z typowymi typami argumentów.

Przykład:

when(mockedIntList.get(1)).thenReturn(3);

Weryfikacja dopasowująca

Istnieje kilka wyspecjalizowanych dopasowań, które mogą oczekiwać / potwierdzać rzeczy takie jak nie. inwokacji na makiecie.

Dla wszystkich poniższych dopasowań rozważmy tę samą listę przykładów, której używaliśmy wcześniej.

final List mockedIntList = mock(ArrayList.class);

1) Mock Invocations

(ja) Proste wywołanie na makiecie weryfikuje, czy mockowana metoda została wywołana / weszła w interakcję, czy nie, ustawiając rozmiar makiety listy na 5.

//arrange when(mockedList.size()).thenReturn(5); // act int size = mockedList.size(); // assert verify(mockedList).size();

(ii) Określona liczba interakcji z metodą pozorowaną weryfikuje liczbę nie. razy oczekiwano, że zostanie wywołana kpina.

najlepszy darmowy program do pobierania youtube na system Windows 10
//arrange when(mockedList.size()).thenReturn(5); // act int size = mockedList.size(); // assert verify(mockedList, times(1)).size();

Aby zweryfikować interakcje 0, po prostu zmień wartość z 1 na 0 jako argument dla dopasowania times ().

//arrange when(mockedList.size()).thenReturn(5); // act int size = mockedList.size(); // assert verify(mockedList, times(0)).size();

W przypadku awarii zwraca następujące wyjątki:

do) Gdy oczekiwane wywołania są mniejsze niż rzeczywiste wywołania:

Przykład: Poszukiwany 2 razy, ale wywołany 3 razy, po czym Mockito wraca - „ weryfikacja.TooManyActualInvocations '

Przykładowy kod:

final List mockedIntList = mock(ArrayList.class); // Arrange when(mockedIntList.get(anyInt())).thenReturn(3); // Act int response = mockedIntList.get(5); response = mockedIntList.get(3); response = mockedIntList.get(100); // Assert verify(mockedIntList, times(2)).get(anyInt());

b) Gdy oczekiwane wywołania są większe niż rzeczywiste wywołania:

Przykład: Poszukiwany 2 razy, ale wywołany 1 raz, po czym Mockito wraca - „ weryfikacja.TooLittleActualInvocations '

final List mockedIntList = mock(ArrayList.class); // Arrange when(mockedIntList.get(anyInt())).thenReturn(3); // Act int response = mockedIntList.get(5); response = mockedIntList.get(3); response = mockedIntList.get(100); // Assert verify(mockedIntList, times(4)).get(anyInt());

(iii) Brak interakcji z określoną metodą wyśmiewanego obiektu.

final List mockedIntList = mock(ArrayList.class); // Arrange when(mockedIntList.get(anyInt())).thenReturn(3); // Act int response = mockedIntList.get(5); // Assert verify(mockedIntList, never()).size();

(iv) Sprawdź kolejność pozorowanych interakcji - jest to szczególnie przydatne, gdy chcesz zapewnić kolejność wywoływania metod na mockowanych obiektach.

Przykład: Operacje podobne do baz danych, w których test powinien weryfikować kolejność, w jakiej odbywały się aktualizacje bazy danych.

Aby zilustrować to przykładem - Przejdźmy do tej samej listy przykładów.

Teraz załóżmy, że kolejność wywołań metod listowych była w kolejności, tj. Get (5), size (), get (2). Zatem kolejność weryfikacji również powinna być taka sama.

// Arrange when(mockedIntList.get(anyInt())).thenReturn(3); when(mockedIntList.size()).thenReturn(100); InOrder mockInvocationSequence = Mockito.inOrder(mockedIntList); // Act int response = mockedIntList.get(5); int size = mockedIntList.size(); response = mockedIntList.get(2); // Assert mockInvocationSequence.verify(mockedIntList, times(1)).get(anyInt()); mockInvocationSequence.verify(mockedIntList).size(); mockInvocationSequence.verify(mockedIntList, times(1)).get(anyInt());

W przypadku złej sekwencji weryfikacji Mockito zgłasza wyjątek - tj. „ weryfikacja.VerificationInOrderFailure ”.

Jeśli więc w powyższym przykładzie zmienię kolejność weryfikacji, zamieniając ostatnie 2 wiersze, zacznę otrzymywać wyjątek VerificationInOrderFailure.

// Arrange when(mockedIntList.get(anyInt())).thenReturn(3); when(mockedIntList.size()).thenReturn(100); InOrder mockInvocationSequence = Mockito.inOrder(mockedIntList); // Act int response = mockedIntList.get(5); int size = mockedIntList.size(); response = mockedIntList.get(2); // Assert mockInvocationSequence.verify(mockedIntList, times(1)).get(anyInt()); mockInvocationSequence.verify(mockedIntList, times(1)).get(anyInt()); mockInvocationSequence.verify(mockedIntList).size();

(v) Sprawdź, czy interakcja miała miejsce co najmniej / co najwyżej kilka razy.

(do) przynajmniej:

Przykład: atleast (3) - weryfikuje, czy wyszydzany obiekt został wywołany / wszedł w interakcję z co najmniej trzykrotnie podczas testu. Zatem każda z interakcji 3 lub większa niż 3 powinna spowodować pomyślną weryfikację.

// Arrange when(mockedIntList.get(anyInt())).thenReturn(3); // Act int response = mockedIntList.get(5); response = mockedIntList.get(2); // Assert verify(mockedIntList, atLeast(2)).get(anyInt());

W przypadku błędów, tj. Gdy rzeczywiste wywołania nie pasują, zgłaszany jest ten sam wyjątek, co w przypadku dopasowania times () tj. „ weryfikacja.TooLittleActualInvocations ”

(b) najbardziej:

Przykład: atmost (3) - sprawdza, czy wyszydzany obiekt został wywołany / wszedł w interakcję z co najmniej trzykrotnie podczas testu. Zatem każda z 0, 1, 2 lub 3 interakcji z makietą powinna sprawić, że weryfikacja zakończy się powodzeniem.

// Arrange when(mockedIntList.get(anyInt())).thenReturn(3); // Act int response = mockedIntList.get(5); response = mockedIntList.get(2); // Assert verify(mockedIntList, atMost(2)).get(anyInt()); verify(mockedIntList, atMost(2)).size();

# 2) Dopasowywanie argumentów

W powyższym wywołaniu dopasowania można łączyć z dopasowującymi argumentami w celu sprawdzenia poprawności argumentów, z którymi wywołano próbę.

  1. każdy()
  2. Określone wartości - sprawdź, używając określonych wartości, jeśli argumenty są znane wcześniej.
  3. Inne dopasowujące argumenty, takie jak - anyInt (), anyString () itp.

Porady & Triki

# 1) Używanie przechwytywania argumentów podczas weryfikacji

Weryfikacja przechwytywania argumentów jest zwykle przydatna, gdy argument używany przez jakąś metodę skrótową nie jest przekazywany bezpośrednio przez wywołanie metody, ale jest tworzony wewnętrznie, gdy wywoływana jest testowana metoda.

Jest to zasadniczo przydatne, gdy metoda zależy od jednego lub więcej współpracowników, których zachowanie zostało zablokowane. Argumenty przekazywane tym współpracownikom są wewnętrznym obiektem lub całkowicie nowym zestawem argumentów.

Weryfikacja faktycznego argumentu, z którym współpracownicy zostaliby wywołani, zapewnia duże zaufanie do testowanego kodu.

Mockito dostarcza ArgumentCaptor, którego można używać z weryfikacją, a następnie, gdy wywoływana jest funkcja „AgumentCaptor.getValue ()”, możemy przypisać faktycznie przechwycony argument przeciwko oczekiwanemu.

Aby to zilustrować, zapoznaj się z poniższym przykładem:

W poniższej metodzie kalkulator cena jest modelem z klasą InventoryModel jest tworzony wewnątrz treści metody, która jest następnie używana przez InventoryService do aktualizacji.

Teraz, jeśli chcesz napisać test sprawdzający, z jakim argumentem wywołała inwentaryzację, możesz po prostu użyć obiektu ArgumentCaptor typu InventoryModel.

Badana metoda:

public double calculatePrice(int itemSkuCode) { double price = 0; // get Item details ItemSku sku = itemService.getItemDetails(itemSkuCode); // update item inventory InventoryModel model = new InventoryModel(); model.setItemSku(sku); model.setItemSuppliers(new String(){'Supplier1'}); inventoryService.updateInventory(model, 1); return sku.getPrice(); }

Kod testowy: Spójrz na krok weryfikacji, w którym weryfikowana jest usługa storageService, zastępowany jest obiekt argumentCaptor, dla którego argument ma zostać dopasowany.

Następnie po prostu potwierdź wartość, wywołując metodę getValue () na obiekcie ArgumentCaptor.

Przykład: ArgumentCaptorObject.getValue ()

public void calculatePrice_withValidItemSku_returnsSuccess() { // Arrange ItemSku item1 = new ItemSku(); item1.setApplicableDiscount(5.00); item1.setPrice(100.00); CustomerProfile customerProfile = new CustomerProfile(); customerProfile.setExtraLoyaltyDiscountPercentage(2.00); double expectedPrice = 93.00; // Arrange when(mockedItemService.getItemDetails(anyInt())).thenReturn(item1); ArgumentCaptor argCaptorInventoryModel = ArgumentCaptor.forClass(InventoryModel.class); // Act priceCalculator.calculatePrice(1234); // Assert verify(mockedItemService).getItemDetails(anyInt()); verify(mockedInventoryService).updateInventory(argCaptorInventoryModel.capture(), eq(1)); assertEquals(argCaptorInventoryModel.getValue().itemSku, item1);

Bez ArgumentCaptor nie byłoby możliwości zidentyfikowania, z jakim argumentem zostało wykonane wywołanie usługi. Najlepiej jest użyć „any ()” lub „any (InventoryModel.class)” do weryfikacji argumentów.

# 2) Typowe wyjątki / błędy podczas korzystania z dopasowań

Podczas korzystania z dopasowań istnieją pewne konwencje, których należy przestrzegać, a ich nieprzestrzeganie powoduje zgłoszenie wyjątku. Najczęstszy, na który się natknąłem, to zgarnianie i weryfikacja.

Jeśli używasz dowolnego argumentMatchers i jeśli metoda stubbed ma więcej niż jeden argument (y), to albo wszystkie argumenty powinny być wymienione z dopasowaniami, w przeciwnym razie żaden z nich nie powinien mieć dopasowań. Co to oznacza?

Spróbujmy to zrozumieć za pomocą scenariusza (a następnie przykładowego kodu dla tego scenariusza)

  1. Załóżmy, że testowana metoda ma podpis podobny do -
    concatenateString (ciąg arg1, ciąg arg2)
  2. Teraz, kiedy stubbing - przypuśćmy, że znasz wartość arg1, ale arg2 jest nieznana, więc decydujesz się użyć dopasowania argumentów, takiego jak - any () lub anyString () i określając wartość dla pierwszego argumentu, na przykład tekst „hello”.
  3. Po zaimplementowaniu powyższego kroku i wykonaniu testu test zgłasza wyjątek o nazwie „InvalidUseOfMatchersException”

Spróbujmy to zrozumieć na przykładzie:

Kod testowy:

// Arrange when(a gMatcher.concatenateString('hello', anyString())).thenReturn('hello world!'); // Act String response = argMatcher.concatenateString('hello', 'abc'); // Assert verify(argMatcher).concatenateString(anyString(), anyString());

Testowana klasa:

public class ArgMatcher { public String concatenateString(String arg1, String arg2) { return arg1.concat(arg2); } }

Po wykonaniu powyższego testu zwraca on „ InvalidUseOfMatchersException '

Jaki jest powód tego wyjątku?

narzędzia do przeglądania kodu open source git

Jest to obcinanie przy użyciu dopasowań części i stałego ciągu znaków, tj. Wymieniliśmy jeden element dopasowujący argument jako „cześć”, a drugi jako anyString (). Teraz są 2 sposoby na pozbycie się tego rodzaju wyjątków (również pamiętaj - to zachowanie dotyczy zarówno konfiguracji Mock, jak i zachowania).

# 1) Użyj dopasowywania argumentów dla wszystkich argumentów:

// Arrange when(a gMatcher.concatenateString(anyString(), anyString())).thenReturn('hello world!'); // Act String response = argMatcher.concatenateString('hello', 'abc'); // Assert verify(argMatcher).concatenateString(anyString(), anyString());

# 2) Użyj eq () jako argumentu dopasowującego, jeśli argument jest znany. Dlatego zamiast określać argument jako „hello”, określ go jako „eq („ hello ”), co powinno sprawić, że kodowanie zakończy się sukcesem.

// Arrange when(argMatcher.concatenateString(anyString(), eq('world'))).thenReturn('hello world!'); // Act String response = argMatcher.concatenateString('hello', 'world'); // Assert verify(argMatcher).concatenateString(anyString(), eq('world'));

Wniosek

W tym artykule zobaczyliśmy, jak korzystać z różnych typów dopasowań udostępnianych przez Mockito.

Tutaj omówiliśmy najczęściej używane. Aby zapoznać się z pełną listą, dobrym źródłem odniesienia jest dokumentacja Mockito Library.

Zapoznaj się z naszym nadchodzącym samouczkiem, aby dowiedzieć się więcej o prywatnych, statycznych i pustych metodach mockowania.

POPRZEDNIA samouczek | NEXT Tutorial

rekomendowane lektury

^