వస్తువులను వెక్కిరించడం

3.1 doReturn() పద్ధతి

ఇప్పుడు మ్యాజిక్ వస్తుంది ...

మీరు నకిలీ మాక్ ఆబ్జెక్ట్‌ని సృష్టించారని అనుకుందాం, అయితే అది ఏదో ఒకవిధంగా పని చేయడానికి మీకు అవసరం. కొన్ని పద్ధతులను పిలిచినప్పుడు, ముఖ్యమైనది ఏదైనా చేయబడింది, లేదా పద్ధతులు నిర్దిష్ట ఫలితాన్ని అందించాయి. ఏం చేయాలి?

మాక్ ఆబ్జెక్ట్‌కు కావలసిన ప్రవర్తనను జోడించడానికి మోకిటో లైబ్రరీ మిమ్మల్ని అనుమతిస్తుంది.

నిర్దిష్ట పద్ధతిని పిలిచినప్పుడు మాక్ ఆబ్జెక్ట్ నిర్దిష్ట ఫలితాన్ని అందించాలని మీరు కోరుకుంటే, కోడ్‌ని ఉపయోగించి ఆబ్జెక్ట్‌కు ఈ “నియమం” జోడించబడుతుంది:

Mockito.doReturn(result).when(an object).method name();

మీరు చూడండి, మెథడ్ కాల్ చివరిలో, method name?ఇక్కడ ఎటువంటి కాల్ జరగడం లేదు. పద్ధతి doReturn()ఒక ప్రత్యేక ప్రాక్సీ-వస్తువును తిరిగి అందిస్తుంది, దీని సహాయంతో ఇది వస్తువు యొక్క పద్ధతుల యొక్క కాల్‌లను పర్యవేక్షిస్తుంది మరియు అందువలన, నియమం వ్రాయబడుతుంది.

మళ్ళీ. మాక్ ఆబ్జెక్ట్‌కు జోడించడానికి నియమాన్ని వ్రాయడం చాలా తెలివైన మార్గం . అటువంటి కోడ్‌ని మీరు చూసినప్పుడు మీ తలపై సరిగ్గా అర్థం చేసుకోవడానికి కొంత నైపుణ్యం అవసరం. అనుభవంతో వస్తుంది.

ఒక నిర్దిష్ట ఉదాహరణ అవసరమని నేను భావిస్తున్నాను. మాక్ క్లాస్ ఆబ్జెక్ట్‌ని క్రియేట్ చేద్దాం ArrayListమరియు దాని పద్ధతిని size()10 సంఖ్యను తిరిగి ఇవ్వమని అడుగుదాం. పూర్తి కోడ్ ఇలా కనిపిస్తుంది:

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

    @Test
    public void whenMockAnnotation () {
         //create a rule: return 10 when calling the size method
        Mockito.doReturn(10).when(mockList).size();

        //the method is called here and will return 10!!
        assertEquals(10, mockList.size());
    }
}

అవును, ఈ కోడ్ పని చేస్తుంది, పరీక్ష విఫలం కాదు.

3.2 ఎప్పుడు() పద్ధతి

మాక్ ఆబ్జెక్ట్‌కు ప్రవర్తన నియమాన్ని జోడించడానికి మరొక మార్గం ఉంది - కాల్ చేయడం ద్వారా Mockito.when(). ఇది ఇలా కనిపిస్తుంది:

Mockito.when(an object.method name()).thenReturn(result);

ఇది మునుపటి మాదిరిగానే మాక్ ఆబ్జెక్ట్ ప్రవర్తన నియమాన్ని వ్రాయడానికి అదే మార్గం. సరిపోల్చండి:

Mockito.doReturn(result).when(an object).method name();

ఇక్కడ సరిగ్గా అదే జరుగుతుంది - కొత్త నియమం యొక్క నిర్మాణం.

నిజమే, మొదటి ఉదాహరణలో రెండు మైనస్‌లు ఉన్నాయి:

• కాల్ చాలా గందరగోళంగా ఉంది.an object.method name()
• methodname()పద్ధతి తిరిగి ఉంటే పని చేయదు void.

సరే, మనకు ఇష్టమైన ఉదాహరణను ఉపయోగించి వ్రాస్దాంMockito.when()

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

    @Test
    public void whenMockAnnotation() {
        //create a rule: return 10 when calling the size method
        Mockito.when(mockList.size() ).thenReturn(10);

        //the method is called here and will return 10!!
        assertEquals(10, mockList.size());
    }
}

3.3 doThrow() పద్ధతి

మాక్ ఆబ్జెక్ట్ పద్ధతిని నిర్దిష్ట ఫలితాన్ని ఎలా అందించాలో మేము కనుగొన్నాము. నేను నిర్దిష్ట మినహాయింపును ఎలా ఇవ్వగలను? దీనికి పంపాలా doReturn()?

పద్ధతి తిరిగి రాకుండా నిరోధించడానికి, అవి మినహాయింపును విసిరివేసేందుకు, మీరు ఉపయోగించి నియమాన్ని సెట్ చేయాలి doThrow().

Mockito.doThrow(exception.class).when(an object).method name();

ఆపై రెండవ ఎంపిక:

Mockito.when(an object.method name()).thenThrow(exception.class);

కొంచెం ఊహించబడింది, సరియైనదా?

బాగా, మీరు చూడండి, మీరు ఇప్పటికే అర్థం చేసుకోవడం ప్రారంభించారు. ఒక ఉదాహరణతో దాన్ని పరిష్కరిద్దాం:

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

    @Test
    public void whenMockAnnotation() {
        Mockito.when(mockList.size() ).thenThrow(IllegalStateException.class);
        mockList.size(); //an exception will be thrown here
    }
}

మీరు నిర్దిష్ట మినహాయింపు వస్తువును విసిరివేయవలసి వస్తే, ఫారమ్ యొక్క నిర్మాణాన్ని ఉపయోగించండి:

Mockito.doThrow(new Exception()).when(an object).method name();

doThrow()పద్ధతికి మినహాయింపు ఆబ్జెక్ట్‌ను పాస్ చేయండి మరియు అది మెథడ్ కాల్ సమయంలో విసిరివేయబడుతుంది.