ప్రాథమిక మోకిటో ఉల్లేఖనాలు

2.1 @మాక్ ఉల్లేఖన

మోకిటోలో మాక్ వస్తువులతో పని చేయడానికి రెండు మార్గాలు ఉన్నాయి. మొదటిది పూర్తిగా వర్చువల్ ఆబ్జెక్ట్‌ను సృష్టించడం , రెండవది ఇప్పటికే ఉన్న వస్తువును రేపర్‌లో చుట్టడం. మొదటిదానితో ప్రారంభిద్దాం.

పూర్తిగా వర్చువల్ ఆబ్జెక్ట్‌ని సృష్టించడానికి, మీరు కోడ్‌ను వ్రాయాలి:

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

ఈ ఉదాహరణలో, మేము నకిలీ అర్రేలిస్ట్‌ని సృష్టించి, దానికి సంబంధించిన సూచనను మాక్‌లిస్ట్ వేరియబుల్‌లో నిల్వ చేస్తాము. ఈ వస్తువు యొక్క పద్ధతులు ఏమీ చేయవు.

దీని కోసం ప్రత్యేక ఉల్లేఖన ఉన్నందున, ఈ కోడ్‌ను మరింత తక్కువగా వ్రాయవచ్చు @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);

అర్రేలిస్ట్ క్లాస్ చుట్టూ రేపర్‌తో ఒక ఉదాహరణ:

@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");
    }
}

ఈ రెండు కోడ్ ఉదాహరణలు సమానం.