Menu

Různé typy Matchers poskytované Mockito

different types matchers provided mockito

sloučit třídění implementace c ++

Vyzkoušejte Náš Nástroj Pro Odstranění Problémů

Úvod do různých typů Matchers v Mockito.

Mocks and Spies in Mockito byly podrobně vysvětleny v našem předchozím tutoriálu podrobností Mockito tréninkové série .

Co jsou Matchers?

Srovnávače jsou jako regulární výrazy nebo zástupné znaky, kde místo konkrétního vstupu (a nebo výstupu) zadáte rozsah / typ vstupu / výstupu, na základě kterého mohou být pahýly / špióni odpočinkové a lze ověřit volání pahýlů.

Všichni zápasníci Mockito jsou součástí ‚ Mockito ' statická třída.

Odpovídající nástroje jsou mocný nástroj, který umožňuje zkrácený způsob nastavení pahýlů a také ověření vyvolání pahýlů zmínkou vstupů argumentů jako obecných typů ke konkrétním hodnotám v závislosti na případu použití nebo scénáři.

Různé typy Matchers poskytované Mockito

Co se naučíte:

Typy Matcherů v Mockitu

V Mockito jsou obecně 2 typy matcherů nebo pokud jde o použití, srovnávače lze použít pro níže uvedené 2 kategorie:

  1. Srovnávače argumentů během nastavení stubu
  2. Porovnávače ověřování pro ověřování skutečných volání stubů

Pro oba typy Matcherů, tj. Argument a Verification, Mockito poskytuje obrovskou sadu matcherů (Click tady a získáte kompletní seznam hráčů, kteří se shodli).

Porovnávače argumentů

Níže jsou uvedeny nejpoužívanější z nich:

U všech níže uvedených položek zvažte testování seznamu IntegerList:

final List mockedIntList = mock(ArrayList.class);

# 1) any () - Přijme jakýkoli objekt (včetně null).

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

#dva) libovolný (jazyková třída Java) -

Příklad : any (ClassUnderTest.class) - Toto je konkrétnější varianta any () a bude přijímat pouze objekty typu třídy, který je uveden jako parametr šablony.

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

# 3) anyBoolean (), anyByte (), anyInt (), anyString (), anyDouble (), anyFloat (), anyList () a mnoho dalších - Všechny tyto nástroje přijímají jakýkoli objekt odpovídajícího datového typu i hodnoty null.

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

# 4) Specifické argumenty - V případech, kdy jsou skutečné argumenty známy předem, je vždy doporučeno je použít, protože poskytují větší jistotu oproti obecným typům argumentů.

Příklad:

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

Porovnávače ověření

Existuje několik specializovaných hráčů, kteří jsou připraveni očekávat / prosazovat věci jako ne. vyvolání na předstíranou.

U všech níže uvedených srovnávačů uvažujme stejný seznam příkladů, který jsme použili dříve.

final List mockedIntList = mock(ArrayList.class);

# 1) Mock Invocations

(i) Jednoduché vyvolání v Mocku ověří, zda byla zesměšněná metoda volána / interagována či nikoli, nastavením velikosti zesměšňovaného seznamu na 5.

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

ii) Specifický počet interakcí s posměšnou metodou ověřuje počet ne. kolikrát se očekávalo, že bude falešný zavolán.

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

Chcete-li ověřit interakce 0, jednoduše změňte hodnotu z 1 na 0 jako argument pro porovnávač times ().

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

V případě selhání vrátí následující výjimky:

na) Pokud jsou očekávané vyvolání menší než skutečné vyvolání:

příklady rozhodovacího stromu v dolování dat

Příklad: Chtěl 2krát, ale 3krát vyvolal, pak se Mockito vrátí - “ ověření. ToManyActualInvocations '

Příklad kódu:

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) Pokud je očekávané vyvolání větší než skutečné vyvolání:

Příklad: Chtěl 2krát, ale vyvolal 1krát, pak se Mockito vrátí - “ verification.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) Žádné interakce se specifickou metodou zesměšňovaného objektu.

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) Ověřte pořadí zesměšňovaných interakcí - To je zvláště užitečné, pokud chcete zajistit pořadí, ve kterém byly metody na zesměšňovaných objektech volány.

Příklad: Operace podobné databázi, kde by test měl ověřit pořadí, ve kterém došlo k aktualizaci databáze.

Pro ilustraci příkladem - Pokračujme se stejným seznamem příkladů.

Nyní předpokládejme, že pořadí volání metod seznamu bylo v pořadí, tj. Get (5), size (), get (2). Pořadí ověření by tedy mělo být stejné.

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

V případě nesprávné ověřovací sekvence vyvolá Mockito výjimku - tj. „ Verifikace.VerificationInOrderFailure “.

Takže ve výše uvedeném příkladu, pokud změním pořadí ověření záměnou posledních 2 řádků, začnu dostávat výjimku 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();

(proti) Ověřte, že došlo k interakci minimálně / maximálně kolikrát.

(na) alespoň:

Příklad: atleast (3) - Ověří, že zesměšňovaný objekt byl během testu vyvolán / interagován s minimálně třikrát. Ověření by tedy mělo být úspěšné díky kterékoli z interakcí 3 nebo vyšších než 3.

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

V případě chyb, tj. Když se skutečné vyvolání neshodují, je vyvolána stejná výjimka jako u porovnávače times (), tj. „ verification.TooLittleActualInvocations “

b) nejvíce:

Příklad: atmost (3) - ověří, zda se vysmívaný objekt během testu vyvolal / interagoval s nejméně třikrát. Takže jakákoli z 0,1,2 nebo 3 interakcí s falešnou stránkou by měla ověřit úspěch.

// 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) Shoda argumentů

Ve výše uvedeném vyvolání lze kombinovat porovnávače společně s porovnávači argumentů, aby se ověřily argumenty, kterými byl falešný volaný.

  1. žádný()
  2. Specifické hodnoty - ověřte pomocí konkrétních hodnot, když jsou argumenty známy předem.
  3. Další argumenty jako - anyInt (), anyString () atd.

tipy a triky

# 1) Použití Argument Capture během ověřování

Ověření zachycení argumentů je obvykle užitečné tam, kde argument používaný nějakou metodou se stubbedem není předán přímo prostřednictvím volání metody, ale je vytvořen interně, když je volána testovaná metoda.

To je v zásadě užitečné, když vaše metoda závisí na jednom nebo více spolupracovníků, jejichž chování bylo zamítnuto. Argumenty předané těmto spolupracovníkům jsou interním objektem nebo zcela novou sadou argumentů.

software pro konverzi videa zdarma pro PC

Ověření skutečného argumentu, pomocí kterého by spolupracovníci byli voláni, zajišťuje velkou důvěru v testovaný kód.

Mockito poskytuje ArgumentCaptor, který lze použít s ověřením, a poté, když se volá „AgumentCaptor.getValue ()“, můžeme uplatnit skutečný zachycený argument proti očekávanému.

Pro ilustraci viz níže uvedený příklad:

V níže uvedené metodě CalcPrice je model s třídou InventoryModel, která je vytvořena uvnitř těla metody, kterou pak InventoryService používá k aktualizaci.

Nyní, pokud chcete napsat test k ověření, s jakým argumentem byla inventarizace volána, můžete jednoduše použít objekt ArgumentCaptor typu InventoryModel.

Zkoušená 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(); }

Zkušební kód: Podívejte se na krok ověření, kde je inventarizace ověřena, objekt argumentCaptor je nahrazen tím, který argument je třeba porovnat.

Pak jednoduše potvrďte hodnotu vyvoláním metody getValue () na objekt ArgumentCaptor.

Příklad: 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 by nebylo možné určit, s jakým argumentem bylo volání služby provedeno. Nejlepší je použít k ověření argumentů „any ()“ nebo „any (InventoryModel.class)“.

# 2) Běžné výjimky / chyby při používání Matcherů

Při používání Matcherů je třeba dodržovat určité konvence, které, pokud se nedodrží, způsobí vyvolání výjimky. Nejběžnější, na kterou jsem narazil, je zatěžování a ověřování.

Pokud používáte any argumentMatchers a pokud má stubbed metoda více než jeden argument (y), pak by všechny argumenty měly být zmíněny s matchers, jinak by žádný z nich neměl mít matchers. Co to znamená?

Zkusme to pochopit pomocí scénáře (a poté ukázky kódu pro tento scénář)

  1. Předpokládejme, že testovaná metoda má podpis jako -
    concatenateString (řetězec arg1, řetězec arg2)
  2. Nyní při stubingu - předpokládejme, že znáte hodnotu arg1, ale arg2 není známa, takže se rozhodnete použít porovnávač argumentů jako - any () nebo anyString () a zadat hodnotu pro první argument jako nějaký text „ahoj“.
  3. Když je implementován výše uvedený krok a test je proveden, test vyvolá výjimku nazvanou „InvalidUseOfMatchersException“

Zkusme to pochopit na příkladu:

Zkušební kód:

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

Testovaná třída:

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

Po provedení výše uvedeného testu se vrátí „ InvalidUseOfMatchersException '

Jaký je důvod této výjimky?

Jedná se o stubbing pomocí part matcheru a part fixed string, tj. Zmínili jsme jeden argument matcher jako „ahoj“ a druhý jako anyString (). Nyní existují 2 způsoby, jak se těchto druhů výjimek zbavit (také mějte na paměti - že toto chování platí jak pro Mock nastavení, tak pro chování).

# 1) Použijte Argument Matchers pro všechny argumenty:

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

# 2) Použijte eq () jako Argument Matcher, kde je známý argument. Takže místo toho, abyste zadali argument jako „ahoj“, zadejte jej jako „eq („ ahoj “), což by mělo učinit stubbing úspěšným.

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

Závěr

V tomto článku jsme viděli, jak používat různé typy porovnávačů poskytované společností Mockito.

Zde jsme pokryli ty nejpoužívanější. Pro odkaz na úplný seznam je dobrým zdrojem dokumentace dokumentace Mockito Library.

Podívejte se na náš nadcházející výukový program a dozvíte se více o soukromých, statických a neplatných metodách zesměšňování.

Výukový program PREV | DALŠÍ výuka

Doporučené čtení

^