பொருள்களில் குறிப்பிட்ட நடத்தையை வெளிப்படுத்துதல்

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