அடிப்படை மோக்கிட்டோ சிறுகுறிப்புகள்

2.1 @மோக் சிறுகுறிப்பு

Mockito இல் போலி பொருள்களுடன் வேலை செய்ய இரண்டு வழிகள் உள்ளன. முதலாவது முழு மெய்நிகர் பொருளை உருவாக்குவது , இரண்டாவது ஏற்கனவே உள்ள பொருளை ஒரு ரேப்பரில் போர்த்துவது. முதல்ல ஆரம்பிப்போம்.

முழு மெய்நிகர் பொருளை உருவாக்க, நீங்கள் குறியீட்டை எழுத வேண்டும்:

ClassName variable name = Mockito.mock(ClassName.class);

உதாரணத்திற்கு ஒரு போலி வரிசை பட்டியல் வகுப்பை உருவாக்குவோம்:

@ExtendWith(MockitoExtension.class)
class MockTest {
    @Test
    public void whenNotUseMockAnnotation_thenCorrect() {
        List mockList = Mockito.mock(ArrayList.class);
        //these methods won't do anything - they are stubs
        mockList.add("one");
        mockList.add("two");
    }
}

இந்த எடுத்துக்காட்டில், நாம் ஒரு போலி வரிசைப்பட்டியலை உருவாக்கி, அதற்கான குறிப்பை mockList மாறியில் சேமிக்கிறோம். இந்த பொருளின் முறைகள் எதுவும் செய்யாது.

இதற்கு ஒரு சிறப்பு சிறுகுறிப்பு இருப்பதால், இந்த குறியீட்டை இன்னும் சுருக்கமாக எழுதலாம் @Mock.

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

    @Test
    public void whenNotUseMockAnnotation_thenCorrect() {
        //these methods won't do anything - they are stubs
        mockList.add("one");
        mockList.add("two");
    }
}

இரண்டாவது வழக்கில், MockitoExtensionஅது வகுப்புக் குறியீட்டையே பகுப்பாய்வு செய்து தேவையான ஸ்டப்களை உருவாக்கும். நீங்கள் முறையை அழைக்க தேவையில்லை Mockito.mock(). ஒரு சிறுகுறிப்பு மற்றும் மெய்நிகர் பொருள் தயாராக உள்ளது. அழகு.

2.2 @ஸ்பை சிறுகுறிப்பு

மொக்கிட்டோவில் உள்ள இரண்டாவது முக்கியமான வகை பொருள்கள், ஏற்கனவே உள்ள பொருட்களின் மீது ரேப்பர்கள். அவை ஒருபுறம், ஏற்கனவே உள்ள வகுப்புகளைப் பயன்படுத்த அனுமதிக்கின்றன, மறுபுறம், அத்தகைய பொருட்களின் அனைத்து முறைகள் மற்றும் மாறிகளுக்கான அழைப்புகளை இடைமறிக்க: தேவையான இடங்களில் அவற்றின் வேலையைச் சரிசெய்ய. அவை போலி பொருள்களைப் போலவே அடிக்கடி பயன்படுத்தப்படுகின்றன.

ஒரு பொருளின் மீது ரேப்பரை உருவாக்க, நீங்கள் குறியீட்டை எழுத வேண்டும்:

ClassName variable name = Mockito.spy(an object);

ArrayList வகுப்பைச் சுற்றி ஒரு ரேப்பருடன் ஒரு எடுத்துக்காட்டு:

@ExtendWith(MockitoExtension.class)
class SpyTest {
    @Test
    public void whenMockAnnotation() {
        List<String> mockList = Mockito.spy(new ArrayList<String>());
        //these methods will work!
        mockList.add("one");
        mockList.add("two");
    }
}

அதன் எளிமையான வடிவத்தில், ஒரு ரேப்பர் பொருளுக்கான அழைப்பு, அழைப்புகளை அசல் பொருளுக்குத் திருப்பிவிடும், அது தனக்குள்ளேயே வைத்திருக்கும் குறிப்பு . எல்லாம் அசல் பொருளைப் போலவே செயல்படும்.

சிறுகுறிப்பைப் பயன்படுத்தி ஒரு ரேப்பரையும் உருவாக்கலாம் - @Spy.

@ExtendWith(MockitoExtension.class)
class SpyTest {
    @Spy
    List mockList = new ArrayList<String>();

    @Test
    public void whenMockAnnotation() {
        // these methods will work!
        mockList.add("one");
        mockList.add("two");
    }
}

இந்த இரண்டு குறியீடு எடுத்துக்காட்டுகளும் சமமானவை.