వస్తువులలో నిర్దిష్ట ప్రవర్తనను బహిర్గతం చేయడం

5.1 వెరిఫై() పద్ధతి

వర్చువల్ వస్తువులను సృష్టించడంతో పాటు, మరొక ఆసక్తికరమైన పని తరచుగా తలెత్తుతుంది - పరీక్షలో ఉన్న తరగతి సరైన వస్తువుల సరైన పద్ధతులను పిలుస్తుందని నిర్ధారించుకోవడానికి. అంతేకాకుండా, అతను సరైన పారామితులతో, మరియు వంటి వాటికి అవసరమైన సంఖ్యలను పిలిచాడు.

దీని కోసం, మోకిటోకు కొన్ని మాయాజాలం కూడా ఉంది - పద్ధతుల కుటుంబం Mockito.verify(…). కాల్ చెకింగ్ పద్ధతిని పేర్కొనే సాధారణ నియమం :

Mockito.verify(an object).method name(parameter);

ఉదాహరణ:

@ExtendWith(MockitoExtension.class)
class VerifyTest {
    @Mock
    List<String> mockList;

    @Test
    public void whenMockAnnotation() {
        //method call
        String name = mockList.get(10);

        // check if the method was called
        Mockito.verify(mockList).get(10);
    }
}

పద్ధతి కాల్ సమయంలో, మేము పరామితి 10తో ఉన్న పద్ధతిని ఆబ్జెక్ట్‌పై పిలవాలని verify()నియమాన్ని సెట్ చేసాము .mockitoListget()

5.2 కాల్‌ల సంఖ్యను తనిఖీ చేసే వెరిఫై() పద్ధతి

కొన్నిసార్లు మరింత క్లిష్టమైన ధృవీకరణ దృశ్యాలు ఉన్నాయి. ఉదాహరణకు, మీరు పద్ధతిని పిలిచారనే వాస్తవాన్ని మాత్రమే కాకుండా, ఉదాహరణకు, ఇది 3 సార్లు పిలువబడిందని మీరు తనిఖీ చేయాలి. లేదా ఇది మీ నుండి ఒక చక్రంలో పిలవబడింది కాబట్టి N సార్లు పిలవబడాలి.

ఇది చేయగలదా అని మేము అడగము, మేము వెంటనే అడుగుతాము: అటువంటి నియమాన్ని ఎలా వ్రాయాలి? మరలా, మోకిటో మమ్మల్ని నిరాశపరచదు. నియమాన్ని ఇలా పేర్కొనవచ్చు:

Mockito.verify(an object,quantity).method name(parameter);

ముఖ్యమైనది! పరిమాణం అనేది ఒక రకం కాదు int, వివిధ నమూనాలను నిర్వచించగల ప్రత్యేక వస్తువు. పద్ధతి యొక్క విభిన్న సంస్కరణలు మీకు గుర్తున్నాయా any()? ఇక్కడ కూడా అదే ఉంది - మీరు వివిధ దృశ్యాలను సెట్ చేయగల ప్రత్యేక పద్ధతులు ఉన్నాయి:

ఉదాహరణ:

String name1 = mockList.get(1);  //method call
String name2 = mockList.get(2);  //method call
String name3 = mockList.get(3);  //method call

//check that the get() method was called 3 times
Mockito.verify(mockList, times(3)).get(anyInt());

మీరు పేర్కొన్న పద్ధతి ఆహ్వానాలు కాకుండా, ఆబ్జెక్ట్‌కు ఇతర సూచనలు చేయకూడదని కూడా మీరు కోరవచ్చు . దీనికి ఒక నియమం ఉంది:

Mockito.verifyNoMoreInteractions(an object);

5.3 పద్ధతి కాల్ ఆర్డర్

మునుపటి నియమాలు కాలింగ్ పద్ధతుల క్రమాన్ని ఏ విధంగానూ నియంత్రించలేదు. నియమం నెరవేర్చబడాలి మరియు అంతే. కానీ మెథడ్ కాల్‌ల క్రమం ముఖ్యమైనప్పుడు పరిస్థితులు ఉన్నాయి మరియు మోకిటో దీనికి కూడా పరిష్కారం కలిగి ఉంది.

ప్రత్యేక వస్తువును ఉపయోగించి పద్ధతి కాల్‌ల యొక్క కఠినమైన క్రమాన్ని పేర్కొనవచ్చు InOrder. మొదట మీరు దీన్ని సృష్టించాలి:

InOrder inOrder = Mockito.inOrder(an object);

ఆపై కాల్ పద్ధతుల ద్వారా దానికి నియమాలను జోడించండి verify().

ఉదాహరణ:

    List<String> mockedList = mock(MyList.class);
    mockedList.size();
    mockedList.add("a parameter");
    mockedList.clear();
 
    InOrder inOrder = Mockito.inOrder(mockedList);
    inOrder.verify(mockedList).size();
    inOrder.verify(mockedList).add("a parameter");
    inOrder.verify(mockedList).clear();

5.4 మోకిటోలో మినహాయింపులను తనిఖీ చేస్తోంది

మినహాయింపులు విసిరిన వాస్తవం కొద్దిగా భిన్నంగా తనిఖీ చేయబడింది. దీన్ని చేయడానికి, పద్ధతిని ఉపయోగించండి assertThrows(). అటువంటి చెక్ యొక్క సాధారణ ఆకృతి:

Assertions.assertThrows(exception.class, () -> an object.methodname());

సంక్లిష్టంగా ఏమీ లేదు.

ఉదాహరణ:

@ExtendWith(MockitoExtension.class)
class ThenThrowTest {
    @Mock
    List mockList;

    @Test
    public void whenMockAnnotation() {
        //set the behavior of the method (needed for demonstration purposes only)
        Mockito.when(mockList.size()).thenThrow(IllegalStateException.class);

        //check if an IllegalStateException will be thrown when calling the size method
        assertThrows(IllegalStateException.class, () -> mockList.size());
    }
}